nextcloud / server

apps/user_ldap/lib/Command/CreateEmptyConfig.php

Indentation +31 added lines, -31 removed lines

@@ -33,39 +33,39 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class CreateEmptyConfig extends Command {
-	/** @var \OCA\User_LDAP\Helper */
-	protected $helper;
+    /** @var \OCA\User_LDAP\Helper */
+    protected $helper;
 
-	/**
-	 * @param Helper $helper
-	 */
-	public function __construct(Helper $helper) {
-		$this->helper = $helper;
-		parent::__construct();
-	}
+    /**
+     * @param Helper $helper
+     */
+    public function __construct(Helper $helper) {
+        $this->helper = $helper;
+        parent::__construct();
+    }
 
-	protected function configure() {
-		$this
-			->setName('ldap:create-empty-config')
-			->setDescription('creates an empty LDAP configuration')
-			->addOption(
-				'only-print-prefix',
-				'p',
-				InputOption::VALUE_NONE,
-				'outputs only the prefix'
-			)
-		;
-	}
+    protected function configure() {
+        $this
+            ->setName('ldap:create-empty-config')
+            ->setDescription('creates an empty LDAP configuration')
+            ->addOption(
+                'only-print-prefix',
+                'p',
+                InputOption::VALUE_NONE,
+                'outputs only the prefix'
+            )
+        ;
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
-		$configPrefix = $this->helper->getNextServerConfigurationPrefix();
-		$configHolder = new Configuration($configPrefix);
-		$configHolder->saveConfiguration();
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        $configPrefix = $this->helper->getNextServerConfigurationPrefix();
+        $configHolder = new Configuration($configPrefix);
+        $configHolder->saveConfiguration();
 
-		$prose = '';
-		if(!$input->getOption('only-print-prefix')) {
-			$prose = 'Created new configuration with configID ';
-		}
-		$output->writeln($prose . "{$configPrefix}");
-	}
+        $prose = '';
+        if(!$input->getOption('only-print-prefix')) {
+            $prose = 'Created new configuration with configID ';
+        }
+        $output->writeln($prose . "{$configPrefix}");
+    }
 }

apps/user_ldap/lib/Command/ShowConfig.php

Indentation +67 added lines, -67 removed lines

@@ -35,77 +35,77 @@
 use OCA\User_LDAP\Configuration;
 
 class ShowConfig extends Command {
-	/** @var \OCA\User_LDAP\Helper */
-	protected $helper;
+    /** @var \OCA\User_LDAP\Helper */
+    protected $helper;
 
-	/**
-	 * @param Helper $helper
-	 */
-	public function __construct(Helper $helper) {
-		$this->helper = $helper;
-		parent::__construct();
-	}
+    /**
+     * @param Helper $helper
+     */
+    public function __construct(Helper $helper) {
+        $this->helper = $helper;
+        parent::__construct();
+    }
 
-	protected function configure() {
-		$this
-			->setName('ldap:show-config')
-			->setDescription('shows the LDAP configuration')
-			->addArgument(
-					'configID',
-					InputArgument::OPTIONAL,
-					'will show the configuration of the specified id'
-				     )
-			->addOption(
-					'show-password',
-					null,
-					InputOption::VALUE_NONE,
-					'show ldap bind password'
-				     )
-		;
-	}
+    protected function configure() {
+        $this
+            ->setName('ldap:show-config')
+            ->setDescription('shows the LDAP configuration')
+            ->addArgument(
+                    'configID',
+                    InputArgument::OPTIONAL,
+                    'will show the configuration of the specified id'
+                        )
+            ->addOption(
+                    'show-password',
+                    null,
+                    InputOption::VALUE_NONE,
+                    'show ldap bind password'
+                        )
+        ;
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
-		$availableConfigs = $this->helper->getServerConfigurationPrefixes();
-		$configID = $input->getArgument('configID');
-		if(!is_null($configID)) {
-			$configIDs[] = $configID;
-			if(!in_array($configIDs[0], $availableConfigs)) {
-				$output->writeln("Invalid configID");
-				return;
-			}
-		} else {
-			$configIDs = $availableConfigs;
-		}
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        $availableConfigs = $this->helper->getServerConfigurationPrefixes();
+        $configID = $input->getArgument('configID');
+        if(!is_null($configID)) {
+            $configIDs[] = $configID;
+            if(!in_array($configIDs[0], $availableConfigs)) {
+                $output->writeln("Invalid configID");
+                return;
+            }
+        } else {
+            $configIDs = $availableConfigs;
+        }
 
-		$this->renderConfigs($configIDs, $output, $input->getOption('show-password'));
-	}
+        $this->renderConfigs($configIDs, $output, $input->getOption('show-password'));
+    }
 
-	/**
-	 * prints the LDAP configuration(s)
-	 * @param string[] configID(s)
-	 * @param OutputInterface $output
-	 * @param bool $withPassword      Set to TRUE to show plaintext passwords in output
-	 */
-	protected function renderConfigs($configIDs, $output, $withPassword) {
-		foreach($configIDs as $id) {
-			$configHolder = new Configuration($id);
-			$configuration = $configHolder->getConfiguration();
-			ksort($configuration);
+    /**
+     * prints the LDAP configuration(s)
+     * @param string[] configID(s)
+     * @param OutputInterface $output
+     * @param bool $withPassword      Set to TRUE to show plaintext passwords in output
+     */
+    protected function renderConfigs($configIDs, $output, $withPassword) {
+        foreach($configIDs as $id) {
+            $configHolder = new Configuration($id);
+            $configuration = $configHolder->getConfiguration();
+            ksort($configuration);
 
-			$table = new Table($output);
-			$table->setHeaders(array('Configuration', $id));
-			$rows = array();
-			foreach($configuration as $key => $value) {
-				if($key === 'ldapAgentPassword' && !$withPassword) {
-					$value = '***';
-				}
-				if(is_array($value)) {
-					$value = implode(';', $value);
-				}
-				$rows[] = array($key, $value);
-			}
-			$table->setRows($rows);
-			$table->render($output);
-		}
-	}
+            $table = new Table($output);
+            $table->setHeaders(array('Configuration', $id));
+            $rows = array();
+            foreach($configuration as $key => $value) {
+                if($key === 'ldapAgentPassword' && !$withPassword) {
+                    $value = '***';
+                }
+                if(is_array($value)) {
+                    $value = implode(';', $value);
+                }
+                $rows[] = array($key, $value);
+            }
+            $table->setRows($rows);
+            $table->render($output);
+        }
+    }
 }

apps/user_ldap/lib/LDAPUtility.php

Indentation +8 added lines, -8 removed lines

@@ -26,13 +26,13 @@
 namespace OCA\User_LDAP;
 
 abstract class LDAPUtility {
-	protected $ldap;
+    protected $ldap;
 
-	/**
-	 * constructor, make sure the subclasses call this one!
-	 * @param ILDAPWrapper $ldapWrapper an instance of an ILDAPWrapper
-	 */
-	public function __construct(ILDAPWrapper $ldapWrapper) {
-		$this->ldap = $ldapWrapper;
-	}
+    /**
+     * constructor, make sure the subclasses call this one!
+     * @param ILDAPWrapper $ldapWrapper an instance of an ILDAPWrapper
+     */
+    public function __construct(ILDAPWrapper $ldapWrapper) {
+        $this->ldap = $ldapWrapper;
+    }
 }

apps/user_ldap/lib/Settings/Section.php

Indentation +46 added lines, -46 removed lines

@@ -28,55 +28,55 @@
 use OCP\Settings\IIconSection;
 
 class Section implements IIconSection {
-	/** @var IL10N */
-	private $l;
-	/** @var IURLGenerator */
-	private $url;
+    /** @var IL10N */
+    private $l;
+    /** @var IURLGenerator */
+    private $url;
 
-	/**
-	 * @param IURLGenerator $url
-	 * @param IL10N $l
-	 */
-	public function __construct(IURLGenerator $url, IL10N $l) {
-		$this->url = $url;
-		$this->l = $l;
-	}
+    /**
+     * @param IURLGenerator $url
+     * @param IL10N $l
+     */
+    public function __construct(IURLGenerator $url, IL10N $l) {
+        $this->url = $url;
+        $this->l = $l;
+    }
 
-	/**
-	 * returns the ID of the section. It is supposed to be a lower case string,
-	 * e.g. 'ldap'
-	 *
-	 * @returns string
-	 */
-	public function getID() {
-		return 'ldap';
-	}
+    /**
+     * returns the ID of the section. It is supposed to be a lower case string,
+     * e.g. 'ldap'
+     *
+     * @returns string
+     */
+    public function getID() {
+        return 'ldap';
+    }
 
-	/**
-	 * returns the translated name as it should be displayed, e.g. 'LDAP / AD
-	 * integration'. Use the L10N service to translate it.
-	 *
-	 * @return string
-	 */
-	public function getName() {
-		return $this->l->t('LDAP / AD integration');
-	}
+    /**
+     * returns the translated name as it should be displayed, e.g. 'LDAP / AD
+     * integration'. Use the L10N service to translate it.
+     *
+     * @return string
+     */
+    public function getName() {
+        return $this->l->t('LDAP / AD integration');
+    }
 
-	/**
-	 * @return int whether the form should be rather on the top or bottom of
-	 * the settings navigation. The sections are arranged in ascending order of
-	 * the priority values. It is required to return a value between 0 and 99.
-	 *
-	 * E.g.: 70
-	 */
-	public function getPriority() {
-		return 25;
-	}
+    /**
+     * @return int whether the form should be rather on the top or bottom of
+     * the settings navigation. The sections are arranged in ascending order of
+     * the priority values. It is required to return a value between 0 and 99.
+     *
+     * E.g.: 70
+     */
+    public function getPriority() {
+        return 25;
+    }
 
-	/**
-	 * {@inheritdoc}
-	 */
-	public function getIcon() {
-		return $this->url->imagePath('user_ldap', 'app-dark.svg');
-	}
+    /**
+     * {@inheritdoc}
+     */
+    public function getIcon() {
+        return $this->url->imagePath('user_ldap', 'app-dark.svg');
+    }
 }

apps/user_ldap/lib/Settings/Admin.php

Indentation +47 added lines, -47 removed lines

@@ -31,59 +31,59 @@
 use OCP\Template;
 
 class Admin implements ISettings {
-	/** @var IL10N */
-	private $l;
+    /** @var IL10N */
+    private $l;
 
-	/**
-	 * @param IL10N $l
-	 */
-	public function __construct(IL10N $l) {
-		$this->l = $l;
-	}
+    /**
+     * @param IL10N $l
+     */
+    public function __construct(IL10N $l) {
+        $this->l = $l;
+    }
 
-	/**
-	 * @return TemplateResponse
-	 */
-	public function getForm() {
-		$helper = new Helper(\OC::$server->getConfig());
-		$prefixes = $helper->getServerConfigurationPrefixes();
-		$hosts = $helper->getServerConfigurationHosts();
+    /**
+     * @return TemplateResponse
+     */
+    public function getForm() {
+        $helper = new Helper(\OC::$server->getConfig());
+        $prefixes = $helper->getServerConfigurationPrefixes();
+        $hosts = $helper->getServerConfigurationHosts();
 
-		$wControls = new Template('user_ldap', 'part.wizardcontrols');
-		$wControls = $wControls->fetchPage();
-		$sControls = new Template('user_ldap', 'part.settingcontrols');
-		$sControls = $sControls->fetchPage();
+        $wControls = new Template('user_ldap', 'part.wizardcontrols');
+        $wControls = $wControls->fetchPage();
+        $sControls = new Template('user_ldap', 'part.settingcontrols');
+        $sControls = $sControls->fetchPage();
 
-		$parameters['serverConfigurationPrefixes'] = $prefixes;
-		$parameters['serverConfigurationHosts'] = $hosts;
-		$parameters['settingControls'] = $sControls;
-		$parameters['wizardControls'] = $wControls;
+        $parameters['serverConfigurationPrefixes'] = $prefixes;
+        $parameters['serverConfigurationHosts'] = $hosts;
+        $parameters['settingControls'] = $sControls;
+        $parameters['wizardControls'] = $wControls;
 
-		// assign default values
-		$config = new Configuration('', false);
-		$defaults = $config->getDefaults();
-		foreach($defaults as $key => $default) {
-			$parameters[$key.'_default'] = $default;
-		}
+        // assign default values
+        $config = new Configuration('', false);
+        $defaults = $config->getDefaults();
+        foreach($defaults as $key => $default) {
+            $parameters[$key.'_default'] = $default;
+        }
 
-		return new TemplateResponse('user_ldap', 'settings', $parameters);
-	}
+        return new TemplateResponse('user_ldap', 'settings', $parameters);
+    }
 
-	/**
-	 * @return string the section ID, e.g. 'sharing'
-	 */
-	public function getSection() {
-		return 'ldap';
-	}
+    /**
+     * @return string the section ID, e.g. 'sharing'
+     */
+    public function getSection() {
+        return 'ldap';
+    }
 
-	/**
-	 * @return int whether the form should be rather on the top or bottom of
-	 * the admin section. The forms are arranged in ascending order of the
-	 * priority values. It is required to return a value between 0 and 100.
-	 *
-	 * E.g.: 70
-	 */
-	public function getPriority() {
-		return 5;
-	}
+    /**
+     * @return int whether the form should be rather on the top or bottom of
+     * the admin section. The forms are arranged in ascending order of the
+     * priority values. It is required to return a value between 0 and 100.
+     *
+     * E.g.: 70
+     */
+    public function getPriority() {
+        return 5;
+    }
 }

apps/user_ldap/lib/User_Proxy.php

Indentation +260 added lines, -260 removed lines

@@ -33,285 +33,285 @@
 use OCP\IConfig;
 
 class User_Proxy extends Proxy implements \OCP\IUserBackend, \OCP\UserInterface, IUserLDAP {
-	private $backends = array();
-	private $refBackend = null;
+    private $backends = array();
+    private $refBackend = null;
 
-	/**
-	 * Constructor
-	 * @param array $serverConfigPrefixes array containing the config Prefixes
-	 */
-	public function __construct(array $serverConfigPrefixes, ILDAPWrapper $ldap, IConfig $ocConfig) {
-		parent::__construct($ldap);
-		foreach($serverConfigPrefixes as $configPrefix) {
-			$this->backends[$configPrefix] =
-				new User_LDAP($this->getAccess($configPrefix), $ocConfig);
-			if(is_null($this->refBackend)) {
-				$this->refBackend = &$this->backends[$configPrefix];
-			}
-		}
-	}
+    /**
+     * Constructor
+     * @param array $serverConfigPrefixes array containing the config Prefixes
+     */
+    public function __construct(array $serverConfigPrefixes, ILDAPWrapper $ldap, IConfig $ocConfig) {
+        parent::__construct($ldap);
+        foreach($serverConfigPrefixes as $configPrefix) {
+            $this->backends[$configPrefix] =
+                new User_LDAP($this->getAccess($configPrefix), $ocConfig);
+            if(is_null($this->refBackend)) {
+                $this->refBackend = &$this->backends[$configPrefix];
+            }
+        }
+    }
 
-	/**
-	 * Tries the backends one after the other until a positive result is returned from the specified method
-	 * @param string $uid the uid connected to the request
-	 * @param string $method the method of the user backend that shall be called
-	 * @param array $parameters an array of parameters to be passed
-	 * @return mixed the result of the method or false
-	 */
-	protected function walkBackends($uid, $method, $parameters) {
-		$cacheKey = $this->getUserCacheKey($uid);
-		foreach($this->backends as $configPrefix => $backend) {
-			$instance = $backend;
-			if(!method_exists($instance, $method)
-				&& method_exists($this->getAccess($configPrefix), $method)) {
-				$instance = $this->getAccess($configPrefix);
-			}
-			if($result = call_user_func_array(array($instance, $method), $parameters)) {
-				$this->writeToCache($cacheKey, $configPrefix);
-				return $result;
-			}
-		}
-		return false;
-	}
+    /**
+     * Tries the backends one after the other until a positive result is returned from the specified method
+     * @param string $uid the uid connected to the request
+     * @param string $method the method of the user backend that shall be called
+     * @param array $parameters an array of parameters to be passed
+     * @return mixed the result of the method or false
+     */
+    protected function walkBackends($uid, $method, $parameters) {
+        $cacheKey = $this->getUserCacheKey($uid);
+        foreach($this->backends as $configPrefix => $backend) {
+            $instance = $backend;
+            if(!method_exists($instance, $method)
+                && method_exists($this->getAccess($configPrefix), $method)) {
+                $instance = $this->getAccess($configPrefix);
+            }
+            if($result = call_user_func_array(array($instance, $method), $parameters)) {
+                $this->writeToCache($cacheKey, $configPrefix);
+                return $result;
+            }
+        }
+        return false;
+    }
 
-	/**
-	 * Asks the backend connected to the server that supposely takes care of the uid from the request.
-	 * @param string $uid the uid connected to the request
-	 * @param string $method the method of the user backend that shall be called
-	 * @param array $parameters an array of parameters to be passed
-	 * @param mixed $passOnWhen the result matches this variable
-	 * @return mixed the result of the method or false
-	 */
-	protected function callOnLastSeenOn($uid, $method, $parameters, $passOnWhen) {
-		$cacheKey = $this->getUserCacheKey($uid);
-		$prefix = $this->getFromCache($cacheKey);
-		//in case the uid has been found in the past, try this stored connection first
-		if(!is_null($prefix)) {
-			if(isset($this->backends[$prefix])) {
-				$instance = $this->backends[$prefix];
-				if(!method_exists($instance, $method)
-					&& method_exists($this->getAccess($prefix), $method)) {
-					$instance = $this->getAccess($prefix);
-				}
-				$result = call_user_func_array(array($instance, $method), $parameters);
-				if($result === $passOnWhen) {
-					//not found here, reset cache to null if user vanished
-					//because sometimes methods return false with a reason
-					$userExists = call_user_func_array(
-						array($this->backends[$prefix], 'userExists'),
-						array($uid)
-					);
-					if(!$userExists) {
-						$this->writeToCache($cacheKey, null);
-					}
-				}
-				return $result;
-			}
-		}
-		return false;
-	}
+    /**
+     * Asks the backend connected to the server that supposely takes care of the uid from the request.
+     * @param string $uid the uid connected to the request
+     * @param string $method the method of the user backend that shall be called
+     * @param array $parameters an array of parameters to be passed
+     * @param mixed $passOnWhen the result matches this variable
+     * @return mixed the result of the method or false
+     */
+    protected function callOnLastSeenOn($uid, $method, $parameters, $passOnWhen) {
+        $cacheKey = $this->getUserCacheKey($uid);
+        $prefix = $this->getFromCache($cacheKey);
+        //in case the uid has been found in the past, try this stored connection first
+        if(!is_null($prefix)) {
+            if(isset($this->backends[$prefix])) {
+                $instance = $this->backends[$prefix];
+                if(!method_exists($instance, $method)
+                    && method_exists($this->getAccess($prefix), $method)) {
+                    $instance = $this->getAccess($prefix);
+                }
+                $result = call_user_func_array(array($instance, $method), $parameters);
+                if($result === $passOnWhen) {
+                    //not found here, reset cache to null if user vanished
+                    //because sometimes methods return false with a reason
+                    $userExists = call_user_func_array(
+                        array($this->backends[$prefix], 'userExists'),
+                        array($uid)
+                    );
+                    if(!$userExists) {
+                        $this->writeToCache($cacheKey, null);
+                    }
+                }
+                return $result;
+            }
+        }
+        return false;
+    }
 
-	/**
-	 * Check if backend implements actions
-	 * @param int $actions bitwise-or'ed actions
-	 * @return boolean
-	 *
-	 * Returns the supported actions as int to be
-	 * compared with OC_USER_BACKEND_CREATE_USER etc.
-	 */
-	public function implementsActions($actions) {
-		//it's the same across all our user backends obviously
-		return $this->refBackend->implementsActions($actions);
-	}
+    /**
+     * Check if backend implements actions
+     * @param int $actions bitwise-or'ed actions
+     * @return boolean
+     *
+     * Returns the supported actions as int to be
+     * compared with OC_USER_BACKEND_CREATE_USER etc.
+     */
+    public function implementsActions($actions) {
+        //it's the same across all our user backends obviously
+        return $this->refBackend->implementsActions($actions);
+    }
 
-	/**
-	 * Backend name to be shown in user management
-	 * @return string the name of the backend to be shown
-	 */
-	public function getBackendName() {
-		return $this->refBackend->getBackendName();
-	}
+    /**
+     * Backend name to be shown in user management
+     * @return string the name of the backend to be shown
+     */
+    public function getBackendName() {
+        return $this->refBackend->getBackendName();
+    }
 
-	/**
-	 * Get a list of all users
-	 *
-	 * @param string $search
-	 * @param null|int $limit
-	 * @param null|int $offset
-	 * @return string[] an array of all uids
-	 */
-	public function getUsers($search = '', $limit = 10, $offset = 0) {
-		//we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
-		$users = array();
-		foreach($this->backends as $backend) {
-			$backendUsers = $backend->getUsers($search, $limit, $offset);
-			if (is_array($backendUsers)) {
-				$users = array_merge($users, $backendUsers);
-			}
-		}
-		return $users;
-	}
+    /**
+     * Get a list of all users
+     *
+     * @param string $search
+     * @param null|int $limit
+     * @param null|int $offset
+     * @return string[] an array of all uids
+     */
+    public function getUsers($search = '', $limit = 10, $offset = 0) {
+        //we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
+        $users = array();
+        foreach($this->backends as $backend) {
+            $backendUsers = $backend->getUsers($search, $limit, $offset);
+            if (is_array($backendUsers)) {
+                $users = array_merge($users, $backendUsers);
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * check if a user exists
-	 * @param string $uid the username
-	 * @return boolean
-	 */
-	public function userExists($uid) {
-		return $this->handleRequest($uid, 'userExists', array($uid));
-	}
+    /**
+     * check if a user exists
+     * @param string $uid the username
+     * @return boolean
+     */
+    public function userExists($uid) {
+        return $this->handleRequest($uid, 'userExists', array($uid));
+    }
 
-	/**
-	 * check if a user exists on LDAP
-	 * @param string|\OCA\User_LDAP\User\User $user either the ownCloud user
-	 * name or an instance of that user
-	 * @return boolean
-	 */
-	public function userExistsOnLDAP($user) {
-		$id = ($user instanceof User) ? $user->getUsername() : $user;
-		return $this->handleRequest($id, 'userExistsOnLDAP', array($user));
-	}
+    /**
+     * check if a user exists on LDAP
+     * @param string|\OCA\User_LDAP\User\User $user either the ownCloud user
+     * name or an instance of that user
+     * @return boolean
+     */
+    public function userExistsOnLDAP($user) {
+        $id = ($user instanceof User) ? $user->getUsername() : $user;
+        return $this->handleRequest($id, 'userExistsOnLDAP', array($user));
+    }
 
-	/**
-	 * Check if the password is correct
-	 * @param string $uid The username
-	 * @param string $password The password
-	 * @return bool
-	 *
-	 * Check if the password is correct without logging in the user
-	 */
-	public function checkPassword($uid, $password) {
-		return $this->handleRequest($uid, 'checkPassword', array($uid, $password));
-	}
+    /**
+     * Check if the password is correct
+     * @param string $uid The username
+     * @param string $password The password
+     * @return bool
+     *
+     * Check if the password is correct without logging in the user
+     */
+    public function checkPassword($uid, $password) {
+        return $this->handleRequest($uid, 'checkPassword', array($uid, $password));
+    }
 
-	/**
-	 * returns the username for the given login name, if available
-	 *
-	 * @param string $loginName
-	 * @return string|false
-	 */
-	public function loginName2UserName($loginName) {
-		$id = 'LOGINNAME,' . $loginName;
-		return $this->handleRequest($id, 'loginName2UserName', array($loginName));
-	}
+    /**
+     * returns the username for the given login name, if available
+     *
+     * @param string $loginName
+     * @return string|false
+     */
+    public function loginName2UserName($loginName) {
+        $id = 'LOGINNAME,' . $loginName;
+        return $this->handleRequest($id, 'loginName2UserName', array($loginName));
+    }
 	
-	/**
-	 * returns the username for the given LDAP DN, if available
-	 *
-	 * @param string $dn
-	 * @return string|false with the username
-	 */
-	public function dn2UserName($dn) {
-		$id = 'DN,' . $dn;
-		return $this->handleRequest($id, 'dn2UserName', array($dn));
-	}
+    /**
+     * returns the username for the given LDAP DN, if available
+     *
+     * @param string $dn
+     * @return string|false with the username
+     */
+    public function dn2UserName($dn) {
+        $id = 'DN,' . $dn;
+        return $this->handleRequest($id, 'dn2UserName', array($dn));
+    }
 
-	/**
-	 * get the user's home directory
-	 * @param string $uid the username
-	 * @return boolean
-	 */
-	public function getHome($uid) {
-		return $this->handleRequest($uid, 'getHome', array($uid));
-	}
+    /**
+     * get the user's home directory
+     * @param string $uid the username
+     * @return boolean
+     */
+    public function getHome($uid) {
+        return $this->handleRequest($uid, 'getHome', array($uid));
+    }
 
-	/**
-	 * get display name of the user
-	 * @param string $uid user ID of the user
-	 * @return string display name
-	 */
-	public function getDisplayName($uid) {
-		return $this->handleRequest($uid, 'getDisplayName', array($uid));
-	}
+    /**
+     * get display name of the user
+     * @param string $uid user ID of the user
+     * @return string display name
+     */
+    public function getDisplayName($uid) {
+        return $this->handleRequest($uid, 'getDisplayName', array($uid));
+    }
 
-	/**
-	 * checks whether the user is allowed to change his avatar in ownCloud
-	 * @param string $uid the ownCloud user name
-	 * @return boolean either the user can or cannot
-	 */
-	public function canChangeAvatar($uid) {
-		return $this->handleRequest($uid, 'canChangeAvatar', array($uid), true);
-	}
+    /**
+     * checks whether the user is allowed to change his avatar in ownCloud
+     * @param string $uid the ownCloud user name
+     * @return boolean either the user can or cannot
+     */
+    public function canChangeAvatar($uid) {
+        return $this->handleRequest($uid, 'canChangeAvatar', array($uid), true);
+    }
 
-	/**
-	 * Get a list of all display names and user ids.
-	 * @param string $search
-	 * @param string|null $limit
-	 * @param string|null $offset
-	 * @return array an array of all displayNames (value) and the corresponding uids (key)
-	 */
-	public function getDisplayNames($search = '', $limit = null, $offset = null) {
-		//we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
-		$users = array();
-		foreach($this->backends as $backend) {
-			$backendUsers = $backend->getDisplayNames($search, $limit, $offset);
-			if (is_array($backendUsers)) {
-				$users = $users + $backendUsers;
-			}
-		}
-		return $users;
-	}
+    /**
+     * Get a list of all display names and user ids.
+     * @param string $search
+     * @param string|null $limit
+     * @param string|null $offset
+     * @return array an array of all displayNames (value) and the corresponding uids (key)
+     */
+    public function getDisplayNames($search = '', $limit = null, $offset = null) {
+        //we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
+        $users = array();
+        foreach($this->backends as $backend) {
+            $backendUsers = $backend->getDisplayNames($search, $limit, $offset);
+            if (is_array($backendUsers)) {
+                $users = $users + $backendUsers;
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * delete a user
-	 * @param string $uid The username of the user to delete
-	 * @return bool
-	 *
-	 * Deletes a user
-	 */
-	public function deleteUser($uid) {
-		return $this->handleRequest($uid, 'deleteUser', array($uid));
-	}
+    /**
+     * delete a user
+     * @param string $uid The username of the user to delete
+     * @return bool
+     *
+     * Deletes a user
+     */
+    public function deleteUser($uid) {
+        return $this->handleRequest($uid, 'deleteUser', array($uid));
+    }
 	
-	/**
-	 * Set password
-	 * @param string $uid The username
-	 * @param string $password The new password
-	 * @return bool
-	 *
-	 */
-	public function setPassword($uid, $password) {
-		return $this->handleRequest($uid, 'setPassword', array($uid, $password));
-	}
+    /**
+     * Set password
+     * @param string $uid The username
+     * @param string $password The new password
+     * @return bool
+     *
+     */
+    public function setPassword($uid, $password) {
+        return $this->handleRequest($uid, 'setPassword', array($uid, $password));
+    }
 
-	/**
-	 * @return bool
-	 */
-	public function hasUserListings() {
-		return $this->refBackend->hasUserListings();
-	}
+    /**
+     * @return bool
+     */
+    public function hasUserListings() {
+        return $this->refBackend->hasUserListings();
+    }
 
-	/**
-	 * Count the number of users
-	 * @return int|bool
-	 */
-	public function countUsers() {
-		$users = false;
-		foreach($this->backends as $backend) {
-			$backendUsers = $backend->countUsers();
-			if ($backendUsers !== false) {
-				$users += $backendUsers;
-			}
-		}
-		return $users;
-	}
+    /**
+     * Count the number of users
+     * @return int|bool
+     */
+    public function countUsers() {
+        $users = false;
+        foreach($this->backends as $backend) {
+            $backendUsers = $backend->countUsers();
+            if ($backendUsers !== false) {
+                $users += $backendUsers;
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * Return access for LDAP interaction.
-	 * @param string $uid
-	 * @return Access instance of Access for LDAP interaction
-	 */
-	public function getLDAPAccess($uid) {
-		return $this->handleRequest($uid, 'getLDAPAccess', array($uid));
-	}
+    /**
+     * Return access for LDAP interaction.
+     * @param string $uid
+     * @return Access instance of Access for LDAP interaction
+     */
+    public function getLDAPAccess($uid) {
+        return $this->handleRequest($uid, 'getLDAPAccess', array($uid));
+    }
 	
-	/**
-	 * Return a new LDAP connection for the specified user.
-	 * The connection needs to be closed manually.
-	 * @param string $uid
-	 * @return resource of the LDAP connection
-	 */
-	public function getNewLDAPConnection($uid) {
-		return $this->handleRequest($uid, 'getNewLDAPConnection', array($uid));
-	}
+    /**
+     * Return a new LDAP connection for the specified user.
+     * The connection needs to be closed manually.
+     * @param string $uid
+     * @return resource of the LDAP connection
+     */
+    public function getNewLDAPConnection($uid) {
+        return $this->handleRequest($uid, 'getNewLDAPConnection', array($uid));
+    }
 }

apps/user_ldap/lib/FilesystemHelper.php

Indentation +14 added lines, -14 removed lines

@@ -29,19 +29,19 @@
  */
 class FilesystemHelper {
 
-	/**
-	 * @brief states whether the filesystem was loaded
-	 * @return bool
-	 */
-	public function isLoaded() {
-		return \OC\Files\Filesystem::$loaded;
-	}
+    /**
+     * @brief states whether the filesystem was loaded
+     * @return bool
+     */
+    public function isLoaded() {
+        return \OC\Files\Filesystem::$loaded;
+    }
 
-	/**
-	 * @brief initializes the filesystem for the given user
-	 * @param string $uid the ownCloud username of the user
-	 */
-	public function setup($uid) {
-		\OC_Util::setupFS($uid);
-	}
+    /**
+     * @brief initializes the filesystem for the given user
+     * @param string $uid the ownCloud username of the user
+     */
+    public function setup($uid) {
+        \OC_Util::setupFS($uid);
+    }
 }

apps/user_ldap/lib/LDAPProvider.php

Indentation +138 added lines, -138 removed lines

@@ -33,155 +33,155 @@
  */
 class LDAPProvider implements ILDAPProvider, IDeletionFlagSupport {
 
-	private $backend;
-	private $logger;
-	private $helper;
-	private $deletedUsersIndex;
+    private $backend;
+    private $logger;
+    private $helper;
+    private $deletedUsersIndex;
 	
-	/**
-	 * Create new LDAPProvider
-	 * @param \OCP\IServerContainer $serverContainer
-	 * @throws \Exception if user_ldap app was not enabled
-	 */
-	public function __construct(IServerContainer $serverContainer, Helper $helper, DeletedUsersIndex $deletedUsersIndex) {
-		$this->logger = $serverContainer->getLogger();
-		$this->helper = $helper;
-		$this->deletedUsersIndex = $deletedUsersIndex;
-		foreach ($serverContainer->getUserManager()->getBackends() as $backend){
-			$this->logger->debug('instance '.get_class($backend).' backend.', ['app' => 'user_ldap']);
-			if ($backend instanceof IUserLDAP) {
-				$this->backend = $backend;
-				return;
-			}
+    /**
+     * Create new LDAPProvider
+     * @param \OCP\IServerContainer $serverContainer
+     * @throws \Exception if user_ldap app was not enabled
+     */
+    public function __construct(IServerContainer $serverContainer, Helper $helper, DeletedUsersIndex $deletedUsersIndex) {
+        $this->logger = $serverContainer->getLogger();
+        $this->helper = $helper;
+        $this->deletedUsersIndex = $deletedUsersIndex;
+        foreach ($serverContainer->getUserManager()->getBackends() as $backend){
+            $this->logger->debug('instance '.get_class($backend).' backend.', ['app' => 'user_ldap']);
+            if ($backend instanceof IUserLDAP) {
+                $this->backend = $backend;
+                return;
+            }
         }
-		throw new \Exception('To use the LDAPProvider, user_ldap app must be enabled');
-	}
+        throw new \Exception('To use the LDAPProvider, user_ldap app must be enabled');
+    }
 	
-	/**
-	 * Translate an user id to LDAP DN
-	 * @param string $uid user id
-	 * @return string with the LDAP DN
-	 * @throws \Exception if translation was unsuccessful
-	 */
-	public function getUserDN($uid) {
-		if(!$this->backend->userExists($uid)){
-			throw new \Exception('User id not found in LDAP');
-		}
-		$result = $this->backend->getLDAPAccess($uid)->username2dn($uid);
-		if(!$result){
-			throw new \Exception('Translation to LDAP DN unsuccessful');
-		}
-		return $result;
-	}
+    /**
+     * Translate an user id to LDAP DN
+     * @param string $uid user id
+     * @return string with the LDAP DN
+     * @throws \Exception if translation was unsuccessful
+     */
+    public function getUserDN($uid) {
+        if(!$this->backend->userExists($uid)){
+            throw new \Exception('User id not found in LDAP');
+        }
+        $result = $this->backend->getLDAPAccess($uid)->username2dn($uid);
+        if(!$result){
+            throw new \Exception('Translation to LDAP DN unsuccessful');
+        }
+        return $result;
+    }
 	
-	/**
-	 * Translate a LDAP DN to an internal user name. If there is no mapping between 
-	 * the DN and the user name, a new one will be created.
-	 * @param string $dn LDAP DN
-	 * @return string with the internal user name
-	 * @throws \Exception if translation was unsuccessful
-	 */
-	public function getUserName($dn) {
-		$result = $this->backend->dn2UserName($dn);
-		if(!$result){
-			throw new \Exception('Translation to internal user name unsuccessful');
-		}
-		return $result;
-	}
+    /**
+     * Translate a LDAP DN to an internal user name. If there is no mapping between 
+     * the DN and the user name, a new one will be created.
+     * @param string $dn LDAP DN
+     * @return string with the internal user name
+     * @throws \Exception if translation was unsuccessful
+     */
+    public function getUserName($dn) {
+        $result = $this->backend->dn2UserName($dn);
+        if(!$result){
+            throw new \Exception('Translation to internal user name unsuccessful');
+        }
+        return $result;
+    }
 	
-	/**
-	 * Convert a stored DN so it can be used as base parameter for LDAP queries.
-	 * @param string $dn the DN in question
-	 * @return string
-	 */
-	public function DNasBaseParameter($dn) {
-		return $this->helper->DNasBaseParameter($dn);
-	}
+    /**
+     * Convert a stored DN so it can be used as base parameter for LDAP queries.
+     * @param string $dn the DN in question
+     * @return string
+     */
+    public function DNasBaseParameter($dn) {
+        return $this->helper->DNasBaseParameter($dn);
+    }
 	
-	/**
-	 * Sanitize a DN received from the LDAP server.
-	 * @param array $dn the DN in question
-	 * @return array the sanitized DN
-	 */
-	public function sanitizeDN($dn) {
-		return $this->helper->sanitizeDN($dn);
-	}
+    /**
+     * Sanitize a DN received from the LDAP server.
+     * @param array $dn the DN in question
+     * @return array the sanitized DN
+     */
+    public function sanitizeDN($dn) {
+        return $this->helper->sanitizeDN($dn);
+    }
 	
-	/**
-	 * Return a new LDAP connection resource for the specified user. 
-	 * The connection must be closed manually.
-	 * @param string $uid user id
-	 * @return resource of the LDAP connection
-	 * @throws \Exception if user id was not found in LDAP
-	 */
-	public function getLDAPConnection($uid) {
-		if(!$this->backend->userExists($uid)){
-			throw new \Exception('User id not found in LDAP');
-		}
-		return $this->backend->getNewLDAPConnection($uid);
-	}
+    /**
+     * Return a new LDAP connection resource for the specified user. 
+     * The connection must be closed manually.
+     * @param string $uid user id
+     * @return resource of the LDAP connection
+     * @throws \Exception if user id was not found in LDAP
+     */
+    public function getLDAPConnection($uid) {
+        if(!$this->backend->userExists($uid)){
+            throw new \Exception('User id not found in LDAP');
+        }
+        return $this->backend->getNewLDAPConnection($uid);
+    }
 	
-	/**
-	 * Get the LDAP base for users.
-	 * @param string $uid user id
-	 * @return string the base for users
-	 * @throws \Exception if user id was not found in LDAP
-	 */
-	public function getLDAPBaseUsers($uid) {
-		if(!$this->backend->userExists($uid)){
-			throw new \Exception('User id not found in LDAP');
-		}	
-		return $this->backend->getLDAPAccess($uid)->getConnection()->getConfiguration()['ldap_base_users'];
-	}
+    /**
+     * Get the LDAP base for users.
+     * @param string $uid user id
+     * @return string the base for users
+     * @throws \Exception if user id was not found in LDAP
+     */
+    public function getLDAPBaseUsers($uid) {
+        if(!$this->backend->userExists($uid)){
+            throw new \Exception('User id not found in LDAP');
+        }	
+        return $this->backend->getLDAPAccess($uid)->getConnection()->getConfiguration()['ldap_base_users'];
+    }
 	
-	/**
-	 * Get the LDAP base for groups.
-	 * @param string $uid user id
-	 * @return string the base for groups
-	 * @throws \Exception if user id was not found in LDAP
-	 */
-	public function getLDAPBaseGroups($uid) {
-		if(!$this->backend->userExists($uid)){
-			throw new \Exception('User id not found in LDAP');
-		}
-		return $this->backend->getLDAPAccess($uid)->getConnection()->getConfiguration()['ldap_base_groups'];
-	}
+    /**
+     * Get the LDAP base for groups.
+     * @param string $uid user id
+     * @return string the base for groups
+     * @throws \Exception if user id was not found in LDAP
+     */
+    public function getLDAPBaseGroups($uid) {
+        if(!$this->backend->userExists($uid)){
+            throw new \Exception('User id not found in LDAP');
+        }
+        return $this->backend->getLDAPAccess($uid)->getConnection()->getConfiguration()['ldap_base_groups'];
+    }
 	
-	/**
-	 * Clear the cache if a cache is used, otherwise do nothing.
-	 * @param string $uid user id
-	 * @throws \Exception if user id was not found in LDAP
-	 */
-	public function clearCache($uid) {
-		if(!$this->backend->userExists($uid)){
-			throw new \Exception('User id not found in LDAP');
-		}
-		$this->backend->getLDAPAccess($uid)->getConnection()->clearCache();
-	}
+    /**
+     * Clear the cache if a cache is used, otherwise do nothing.
+     * @param string $uid user id
+     * @throws \Exception if user id was not found in LDAP
+     */
+    public function clearCache($uid) {
+        if(!$this->backend->userExists($uid)){
+            throw new \Exception('User id not found in LDAP');
+        }
+        $this->backend->getLDAPAccess($uid)->getConnection()->clearCache();
+    }
 	
-	/**
-	 * Check whether a LDAP DN exists
-	 * @param string $dn LDAP DN
-	 * @return bool whether the DN exists
-	 */
-	public function dnExists($dn) {
-		$result = $this->backend->dn2UserName($dn);
-		return !$result ? false : true;
-	}
+    /**
+     * Check whether a LDAP DN exists
+     * @param string $dn LDAP DN
+     * @return bool whether the DN exists
+     */
+    public function dnExists($dn) {
+        $result = $this->backend->dn2UserName($dn);
+        return !$result ? false : true;
+    }
 	
-	/**
-	 * Flag record for deletion.
-	 * @param string $uid user id
-	 */
-	public function flagRecord($uid) {
-		$this->deletedUsersIndex->markUser($uid);
-	}
+    /**
+     * Flag record for deletion.
+     * @param string $uid user id
+     */
+    public function flagRecord($uid) {
+        $this->deletedUsersIndex->markUser($uid);
+    }
 	
-	/**
-	 * Unflag record for deletion.
-	 * @param string $uid user id
-	 */
-	public function unflagRecord($uid) {
-		//do nothing
-	}
+    /**
+     * Unflag record for deletion.
+     * @param string $uid user id
+     */
+    public function unflagRecord($uid) {
+        //do nothing
+    }
 }

apps/user_ldap/lib/User_LDAP.php

Indentation +485 added lines, -485 removed lines

@@ -44,492 +44,492 @@
 use OCP\Util;
 
 class User_LDAP extends BackendUtility implements \OCP\IUserBackend, \OCP\UserInterface, IUserLDAP {
-	/** @var string[] $homesToKill */
-	protected $homesToKill = array();
-
-	/** @var \OCP\IConfig */
-	protected $ocConfig;
-
-	/**
-	 * @param Access $access
-	 * @param \OCP\IConfig $ocConfig
-	 */
-	public function __construct(Access $access, IConfig $ocConfig) {
-		parent::__construct($access);
-		$this->ocConfig = $ocConfig;
-	}
-
-	/**
-	 * checks whether the user is allowed to change his avatar in ownCloud
-	 * @param string $uid the ownCloud user name
-	 * @return boolean either the user can or cannot
-	 */
-	public function canChangeAvatar($uid) {
-		$user = $this->access->userManager->get($uid);
-		if(!$user instanceof User) {
-			return false;
-		}
-		if($user->getAvatarImage() === false) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * returns the username for the given login name, if available
-	 *
-	 * @param string $loginName
-	 * @return string|false
-	 */
-	public function loginName2UserName($loginName) {
-		$cacheKey = 'loginName2UserName-'.$loginName;
-		$username = $this->access->connection->getFromCache($cacheKey);
-		if(!is_null($username)) {
-			return $username;
-		}
-
-		try {
-			$ldapRecord = $this->getLDAPUserByLoginName($loginName);
-			$user = $this->access->userManager->get($ldapRecord['dn'][0]);
-			if($user instanceof OfflineUser) {
-				// this path is not really possible, however get() is documented
-				// to return User or OfflineUser so we are very defensive here.
-				$this->access->connection->writeToCache($cacheKey, false);
-				return false;
-			}
-			$username = $user->getUsername();
-			$this->access->connection->writeToCache($cacheKey, $username);
-			return $username;
-		} catch (NotOnLDAP $e) {
-			$this->access->connection->writeToCache($cacheKey, false);
-			return false;
-		}
-	}
+    /** @var string[] $homesToKill */
+    protected $homesToKill = array();
+
+    /** @var \OCP\IConfig */
+    protected $ocConfig;
+
+    /**
+     * @param Access $access
+     * @param \OCP\IConfig $ocConfig
+     */
+    public function __construct(Access $access, IConfig $ocConfig) {
+        parent::__construct($access);
+        $this->ocConfig = $ocConfig;
+    }
+
+    /**
+     * checks whether the user is allowed to change his avatar in ownCloud
+     * @param string $uid the ownCloud user name
+     * @return boolean either the user can or cannot
+     */
+    public function canChangeAvatar($uid) {
+        $user = $this->access->userManager->get($uid);
+        if(!$user instanceof User) {
+            return false;
+        }
+        if($user->getAvatarImage() === false) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * returns the username for the given login name, if available
+     *
+     * @param string $loginName
+     * @return string|false
+     */
+    public function loginName2UserName($loginName) {
+        $cacheKey = 'loginName2UserName-'.$loginName;
+        $username = $this->access->connection->getFromCache($cacheKey);
+        if(!is_null($username)) {
+            return $username;
+        }
+
+        try {
+            $ldapRecord = $this->getLDAPUserByLoginName($loginName);
+            $user = $this->access->userManager->get($ldapRecord['dn'][0]);
+            if($user instanceof OfflineUser) {
+                // this path is not really possible, however get() is documented
+                // to return User or OfflineUser so we are very defensive here.
+                $this->access->connection->writeToCache($cacheKey, false);
+                return false;
+            }
+            $username = $user->getUsername();
+            $this->access->connection->writeToCache($cacheKey, $username);
+            return $username;
+        } catch (NotOnLDAP $e) {
+            $this->access->connection->writeToCache($cacheKey, false);
+            return false;
+        }
+    }
 	
-	/**
-	 * returns the username for the given LDAP DN, if available
-	 *
-	 * @param string $dn
-	 * @return string|false with the username
-	 */
-	public function dn2UserName($dn) {
-		return $this->access->dn2username($dn);
-	}
-
-	/**
-	 * returns an LDAP record based on a given login name
-	 *
-	 * @param string $loginName
-	 * @return array
-	 * @throws NotOnLDAP
-	 */
-	public function getLDAPUserByLoginName($loginName) {
-		//find out dn of the user name
-		$attrs = $this->access->userManager->getAttributes();
-		$users = $this->access->fetchUsersByLoginName($loginName, $attrs);
-		if(count($users) < 1) {
-			throw new NotOnLDAP('No user available for the given login name on ' .
-				$this->access->connection->ldapHost . ':' . $this->access->connection->ldapPort);
-		}
-		return $users[0];
-	}
-
-	/**
-	 * Check if the password is correct without logging in the user
-	 *
-	 * @param string $uid The username
-	 * @param string $password The password
-	 * @return false|string
-	 */
-	public function checkPassword($uid, $password) {
-		try {
-			$ldapRecord = $this->getLDAPUserByLoginName($uid);
-		} catch(NotOnLDAP $e) {
-			if($this->ocConfig->getSystemValue('loglevel', Util::WARN) === Util::DEBUG) {
-				\OC::$server->getLogger()->logException($e, ['app' => 'user_ldap']);
-			}
-			return false;
-		}
-		$dn = $ldapRecord['dn'][0];
-		$user = $this->access->userManager->get($dn);
-
-		if(!$user instanceof User) {
-			Util::writeLog('user_ldap',
-				'LDAP Login: Could not get user object for DN ' . $dn .
-				'. Maybe the LDAP entry has no set display name attribute?',
-				Util::WARN);
-			return false;
-		}
-		if($user->getUsername() !== false) {
-			//are the credentials OK?
-			if(!$this->access->areCredentialsValid($dn, $password)) {
-				return false;
-			}
-
-			$this->access->cacheUserExists($user->getUsername());
-			$user->processAttributes($ldapRecord);
-			$user->markLogin();
-
-			return $user->getUsername();
-		}
-
-		return false;
-	}
-
-	/**
-	 * Set password
-	 * @param string $uid The username
-	 * @param string $password The new password
-	 * @return bool
-	 */
-	public function setPassword($uid, $password) {
-		$user = $this->access->userManager->get($uid);
-
-		if(!$user instanceof User) {
-			throw new \Exception('LDAP setPassword: Could not get user object for uid ' . $uid .
-				'. Maybe the LDAP entry has no set display name attribute?');
-		}
-		if($user->getUsername() !== false) {
-			return $this->access->setPassword($user->getDN(), $password);
-		}
-
-		return false;
-	}
-
-	/**
-	 * Get a list of all users
-	 *
-	 * @param string $search
-	 * @param integer $limit
-	 * @param integer $offset
-	 * @return string[] an array of all uids
-	 */
-	public function getUsers($search = '', $limit = 10, $offset = 0) {
-		$search = $this->access->escapeFilterPart($search, true);
-		$cachekey = 'getUsers-'.$search.'-'.$limit.'-'.$offset;
-
-		//check if users are cached, if so return
-		$ldap_users = $this->access->connection->getFromCache($cachekey);
-		if(!is_null($ldap_users)) {
-			return $ldap_users;
-		}
-
-		// if we'd pass -1 to LDAP search, we'd end up in a Protocol
-		// error. With a limit of 0, we get 0 results. So we pass null.
-		if($limit <= 0) {
-			$limit = null;
-		}
-		$filter = $this->access->combineFilterWithAnd(array(
-			$this->access->connection->ldapUserFilter,
-			$this->access->connection->ldapUserDisplayName . '=*',
-			$this->access->getFilterPartForUserSearch($search)
-		));
-
-		Util::writeLog('user_ldap',
-			'getUsers: Options: search '.$search.' limit '.$limit.' offset '.$offset.' Filter: '.$filter,
-			Util::DEBUG);
-		//do the search and translate results to owncloud names
-		$ldap_users = $this->access->fetchListOfUsers(
-			$filter,
-			$this->access->userManager->getAttributes(true),
-			$limit, $offset);
-		$ldap_users = $this->access->ownCloudUserNames($ldap_users);
-		Util::writeLog('user_ldap', 'getUsers: '.count($ldap_users). ' Users found', Util::DEBUG);
-
-		$this->access->connection->writeToCache($cachekey, $ldap_users);
-		return $ldap_users;
-	}
-
-	/**
-	 * checks whether a user is still available on LDAP
-	 *
-	 * @param string|\OCA\User_LDAP\User\User $user either the ownCloud user
-	 * name or an instance of that user
-	 * @return bool
-	 * @throws \Exception
-	 * @throws \OC\ServerNotAvailableException
-	 */
-	public function userExistsOnLDAP($user) {
-		if(is_string($user)) {
-			$user = $this->access->userManager->get($user);
-		}
-		if(is_null($user)) {
-			return false;
-		}
-
-		$dn = $user->getDN();
-		//check if user really still exists by reading its entry
-		if(!is_array($this->access->readAttribute($dn, '', $this->access->connection->ldapUserFilter))) {
-			$lcr = $this->access->connection->getConnectionResource();
-			if(is_null($lcr)) {
-				throw new \Exception('No LDAP Connection to server ' . $this->access->connection->ldapHost);
-			}
-
-			try {
-				$uuid = $this->access->getUserMapper()->getUUIDByDN($dn);
-				if(!$uuid) {
-					return false;
-				}
-				$newDn = $this->access->getUserDnByUuid($uuid);
-				//check if renamed user is still valid by reapplying the ldap filter
-				if(!is_array($this->access->readAttribute($newDn, '', $this->access->connection->ldapUserFilter))) {
-					return false;
-				}
-				$this->access->getUserMapper()->setDNbyUUID($newDn, $uuid);
-				return true;
-			} catch (\Exception $e) {
-				return false;
-			}
-		}
-
-		if($user instanceof OfflineUser) {
-			$user->unmark();
-		}
-
-		return true;
-	}
-
-	/**
-	 * check if a user exists
-	 * @param string $uid the username
-	 * @return boolean
-	 * @throws \Exception when connection could not be established
-	 */
-	public function userExists($uid) {
-		$userExists = $this->access->connection->getFromCache('userExists'.$uid);
-		if(!is_null($userExists)) {
-			return (bool)$userExists;
-		}
-		//getting dn, if false the user does not exist. If dn, he may be mapped only, requires more checking.
-		$user = $this->access->userManager->get($uid);
-
-		if(is_null($user)) {
-			Util::writeLog('user_ldap', 'No DN found for '.$uid.' on '.
-				$this->access->connection->ldapHost, Util::DEBUG);
-			$this->access->connection->writeToCache('userExists'.$uid, false);
-			return false;
-		} else if($user instanceof OfflineUser) {
-			//express check for users marked as deleted. Returning true is
-			//necessary for cleanup
-			return true;
-		}
-
-		$result = $this->userExistsOnLDAP($user);
-		$this->access->connection->writeToCache('userExists'.$uid, $result);
-		if($result === true) {
-			$user->update();
-		}
-		return $result;
-	}
-
-	/**
-	* returns whether a user was deleted in LDAP
-	*
-	* @param string $uid The username of the user to delete
-	* @return bool
-	*/
-	public function deleteUser($uid) {
-		$marked = $this->ocConfig->getUserValue($uid, 'user_ldap', 'isDeleted', 0);
-		if(intval($marked) === 0) {
-			\OC::$server->getLogger()->notice(
-				'User '.$uid . ' is not marked as deleted, not cleaning up.',
-				array('app' => 'user_ldap'));
-			return false;
-		}
-		\OC::$server->getLogger()->info('Cleaning up after user ' . $uid,
-			array('app' => 'user_ldap'));
-
-		//Get Home Directory out of user preferences so we can return it later,
-		//necessary for removing directories as done by OC_User.
-		$home = $this->ocConfig->getUserValue($uid, 'user_ldap', 'homePath', '');
-		$this->homesToKill[$uid] = $home;
-		$this->access->getUserMapper()->unmap($uid);
-
-		return true;
-	}
-
-	/**
-	 * get the user's home directory
-	 *
-	 * @param string $uid the username
-	 * @return bool|string
-	 * @throws NoUserException
-	 * @throws \Exception
-	 */
-	public function getHome($uid) {
-		if(isset($this->homesToKill[$uid]) && !empty($this->homesToKill[$uid])) {
-			//a deleted user who needs some clean up
-			return $this->homesToKill[$uid];
-		}
-
-		// user Exists check required as it is not done in user proxy!
-		if(!$this->userExists($uid)) {
-			return false;
-		}
-
-		$cacheKey = 'getHome'.$uid;
-		$path = $this->access->connection->getFromCache($cacheKey);
-		if(!is_null($path)) {
-			return $path;
-		}
-
-		$user = $this->access->userManager->get($uid);
-		if(is_null($user) || ($user instanceof OfflineUser && !$this->userExistsOnLDAP($user->getOCName()))) {
-			throw new NoUserException($uid . ' is not a valid user anymore');
-		}
-		if($user instanceof OfflineUser) {
-			// apparently this user survived the userExistsOnLDAP check,
-			// we request the user instance again in order to retrieve a User
-			// instance instead
-			$user = $this->access->userManager->get($uid);
-		}
-		$path = $user->getHomePath();
-		$this->access->cacheUserHome($uid, $path);
-
-		return $path;
-	}
-
-	/**
-	 * get display name of the user
-	 * @param string $uid user ID of the user
-	 * @return string|false display name
-	 */
-	public function getDisplayName($uid) {
-		if(!$this->userExists($uid)) {
-			return false;
-		}
-
-		$cacheKey = 'getDisplayName'.$uid;
-		if(!is_null($displayName = $this->access->connection->getFromCache($cacheKey))) {
-			return $displayName;
-		}
-
-		//Check whether the display name is configured to have a 2nd feature
-		$additionalAttribute = $this->access->connection->ldapUserDisplayName2;
-		$displayName2 = '';
-		if ($additionalAttribute !== '') {
-			$displayName2 = $this->access->readAttribute(
-				$this->access->username2dn($uid),
-				$additionalAttribute);
-		}
-
-		$displayName = $this->access->readAttribute(
-			$this->access->username2dn($uid),
-			$this->access->connection->ldapUserDisplayName);
-
-		if($displayName && (count($displayName) > 0)) {
-			$displayName = $displayName[0];
-
-			if (is_array($displayName2)){
-				$displayName2 = count($displayName2) > 0 ? $displayName2[0] : '';
-			}
-
-			$user = $this->access->userManager->get($uid);
-			if ($user instanceof User) {
-				$displayName = $user->composeAndStoreDisplayName($displayName, $displayName2);
-				$this->access->connection->writeToCache($cacheKey, $displayName);
-			}
-			if ($user instanceof OfflineUser) {
-				/** @var OfflineUser $user*/
-				$displayName = $user->getDisplayName();
-			}
-			return $displayName;
-		}
-
-		return null;
-	}
-
-	/**
-	 * Get a list of all display names
-	 *
-	 * @param string $search
-	 * @param string|null $limit
-	 * @param string|null $offset
-	 * @return array an array of all displayNames (value) and the corresponding uids (key)
-	 */
-	public function getDisplayNames($search = '', $limit = null, $offset = null) {
-		$cacheKey = 'getDisplayNames-'.$search.'-'.$limit.'-'.$offset;
-		if(!is_null($displayNames = $this->access->connection->getFromCache($cacheKey))) {
-			return $displayNames;
-		}
-
-		$displayNames = array();
-		$users = $this->getUsers($search, $limit, $offset);
-		foreach ($users as $user) {
-			$displayNames[$user] = $this->getDisplayName($user);
-		}
-		$this->access->connection->writeToCache($cacheKey, $displayNames);
-		return $displayNames;
-	}
-
-	/**
-	* Check if backend implements actions
-	* @param int $actions bitwise-or'ed actions
-	* @return boolean
-	*
-	* Returns the supported actions as int to be
-	* compared with OC_USER_BACKEND_CREATE_USER etc.
-	*/
-	public function implementsActions($actions) {
-		return (bool)((Backend::CHECK_PASSWORD
-			| Backend::GET_HOME
-			| Backend::GET_DISPLAYNAME
-			| Backend::PROVIDE_AVATAR
-			| Backend::COUNT_USERS
-			| ((intval($this->access->connection->turnOnPasswordChange) === 1)?(Backend::SET_PASSWORD):0))
-			& $actions);
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function hasUserListings() {
-		return true;
-	}
-
-	/**
-	 * counts the users in LDAP
-	 *
-	 * @return int|bool
-	 */
-	public function countUsers() {
-		$filter = $this->access->getFilterForUserCount();
-		$cacheKey = 'countUsers-'.$filter;
-		if(!is_null($entries = $this->access->connection->getFromCache($cacheKey))) {
-			return $entries;
-		}
-		$entries = $this->access->countUsers($filter);
-		$this->access->connection->writeToCache($cacheKey, $entries);
-		return $entries;
-	}
-
-	/**
-	 * Backend name to be shown in user management
-	 * @return string the name of the backend to be shown
-	 */
-	public function getBackendName(){
-		return 'LDAP';
-	}
+    /**
+     * returns the username for the given LDAP DN, if available
+     *
+     * @param string $dn
+     * @return string|false with the username
+     */
+    public function dn2UserName($dn) {
+        return $this->access->dn2username($dn);
+    }
+
+    /**
+     * returns an LDAP record based on a given login name
+     *
+     * @param string $loginName
+     * @return array
+     * @throws NotOnLDAP
+     */
+    public function getLDAPUserByLoginName($loginName) {
+        //find out dn of the user name
+        $attrs = $this->access->userManager->getAttributes();
+        $users = $this->access->fetchUsersByLoginName($loginName, $attrs);
+        if(count($users) < 1) {
+            throw new NotOnLDAP('No user available for the given login name on ' .
+                $this->access->connection->ldapHost . ':' . $this->access->connection->ldapPort);
+        }
+        return $users[0];
+    }
+
+    /**
+     * Check if the password is correct without logging in the user
+     *
+     * @param string $uid The username
+     * @param string $password The password
+     * @return false|string
+     */
+    public function checkPassword($uid, $password) {
+        try {
+            $ldapRecord = $this->getLDAPUserByLoginName($uid);
+        } catch(NotOnLDAP $e) {
+            if($this->ocConfig->getSystemValue('loglevel', Util::WARN) === Util::DEBUG) {
+                \OC::$server->getLogger()->logException($e, ['app' => 'user_ldap']);
+            }
+            return false;
+        }
+        $dn = $ldapRecord['dn'][0];
+        $user = $this->access->userManager->get($dn);
+
+        if(!$user instanceof User) {
+            Util::writeLog('user_ldap',
+                'LDAP Login: Could not get user object for DN ' . $dn .
+                '. Maybe the LDAP entry has no set display name attribute?',
+                Util::WARN);
+            return false;
+        }
+        if($user->getUsername() !== false) {
+            //are the credentials OK?
+            if(!$this->access->areCredentialsValid($dn, $password)) {
+                return false;
+            }
+
+            $this->access->cacheUserExists($user->getUsername());
+            $user->processAttributes($ldapRecord);
+            $user->markLogin();
+
+            return $user->getUsername();
+        }
+
+        return false;
+    }
+
+    /**
+     * Set password
+     * @param string $uid The username
+     * @param string $password The new password
+     * @return bool
+     */
+    public function setPassword($uid, $password) {
+        $user = $this->access->userManager->get($uid);
+
+        if(!$user instanceof User) {
+            throw new \Exception('LDAP setPassword: Could not get user object for uid ' . $uid .
+                '. Maybe the LDAP entry has no set display name attribute?');
+        }
+        if($user->getUsername() !== false) {
+            return $this->access->setPassword($user->getDN(), $password);
+        }
+
+        return false;
+    }
+
+    /**
+     * Get a list of all users
+     *
+     * @param string $search
+     * @param integer $limit
+     * @param integer $offset
+     * @return string[] an array of all uids
+     */
+    public function getUsers($search = '', $limit = 10, $offset = 0) {
+        $search = $this->access->escapeFilterPart($search, true);
+        $cachekey = 'getUsers-'.$search.'-'.$limit.'-'.$offset;
+
+        //check if users are cached, if so return
+        $ldap_users = $this->access->connection->getFromCache($cachekey);
+        if(!is_null($ldap_users)) {
+            return $ldap_users;
+        }
+
+        // if we'd pass -1 to LDAP search, we'd end up in a Protocol
+        // error. With a limit of 0, we get 0 results. So we pass null.
+        if($limit <= 0) {
+            $limit = null;
+        }
+        $filter = $this->access->combineFilterWithAnd(array(
+            $this->access->connection->ldapUserFilter,
+            $this->access->connection->ldapUserDisplayName . '=*',
+            $this->access->getFilterPartForUserSearch($search)
+        ));
+
+        Util::writeLog('user_ldap',
+            'getUsers: Options: search '.$search.' limit '.$limit.' offset '.$offset.' Filter: '.$filter,
+            Util::DEBUG);
+        //do the search and translate results to owncloud names
+        $ldap_users = $this->access->fetchListOfUsers(
+            $filter,
+            $this->access->userManager->getAttributes(true),
+            $limit, $offset);
+        $ldap_users = $this->access->ownCloudUserNames($ldap_users);
+        Util::writeLog('user_ldap', 'getUsers: '.count($ldap_users). ' Users found', Util::DEBUG);
+
+        $this->access->connection->writeToCache($cachekey, $ldap_users);
+        return $ldap_users;
+    }
+
+    /**
+     * checks whether a user is still available on LDAP
+     *
+     * @param string|\OCA\User_LDAP\User\User $user either the ownCloud user
+     * name or an instance of that user
+     * @return bool
+     * @throws \Exception
+     * @throws \OC\ServerNotAvailableException
+     */
+    public function userExistsOnLDAP($user) {
+        if(is_string($user)) {
+            $user = $this->access->userManager->get($user);
+        }
+        if(is_null($user)) {
+            return false;
+        }
+
+        $dn = $user->getDN();
+        //check if user really still exists by reading its entry
+        if(!is_array($this->access->readAttribute($dn, '', $this->access->connection->ldapUserFilter))) {
+            $lcr = $this->access->connection->getConnectionResource();
+            if(is_null($lcr)) {
+                throw new \Exception('No LDAP Connection to server ' . $this->access->connection->ldapHost);
+            }
+
+            try {
+                $uuid = $this->access->getUserMapper()->getUUIDByDN($dn);
+                if(!$uuid) {
+                    return false;
+                }
+                $newDn = $this->access->getUserDnByUuid($uuid);
+                //check if renamed user is still valid by reapplying the ldap filter
+                if(!is_array($this->access->readAttribute($newDn, '', $this->access->connection->ldapUserFilter))) {
+                    return false;
+                }
+                $this->access->getUserMapper()->setDNbyUUID($newDn, $uuid);
+                return true;
+            } catch (\Exception $e) {
+                return false;
+            }
+        }
+
+        if($user instanceof OfflineUser) {
+            $user->unmark();
+        }
+
+        return true;
+    }
+
+    /**
+     * check if a user exists
+     * @param string $uid the username
+     * @return boolean
+     * @throws \Exception when connection could not be established
+     */
+    public function userExists($uid) {
+        $userExists = $this->access->connection->getFromCache('userExists'.$uid);
+        if(!is_null($userExists)) {
+            return (bool)$userExists;
+        }
+        //getting dn, if false the user does not exist. If dn, he may be mapped only, requires more checking.
+        $user = $this->access->userManager->get($uid);
+
+        if(is_null($user)) {
+            Util::writeLog('user_ldap', 'No DN found for '.$uid.' on '.
+                $this->access->connection->ldapHost, Util::DEBUG);
+            $this->access->connection->writeToCache('userExists'.$uid, false);
+            return false;
+        } else if($user instanceof OfflineUser) {
+            //express check for users marked as deleted. Returning true is
+            //necessary for cleanup
+            return true;
+        }
+
+        $result = $this->userExistsOnLDAP($user);
+        $this->access->connection->writeToCache('userExists'.$uid, $result);
+        if($result === true) {
+            $user->update();
+        }
+        return $result;
+    }
+
+    /**
+     * returns whether a user was deleted in LDAP
+     *
+     * @param string $uid The username of the user to delete
+     * @return bool
+     */
+    public function deleteUser($uid) {
+        $marked = $this->ocConfig->getUserValue($uid, 'user_ldap', 'isDeleted', 0);
+        if(intval($marked) === 0) {
+            \OC::$server->getLogger()->notice(
+                'User '.$uid . ' is not marked as deleted, not cleaning up.',
+                array('app' => 'user_ldap'));
+            return false;
+        }
+        \OC::$server->getLogger()->info('Cleaning up after user ' . $uid,
+            array('app' => 'user_ldap'));
+
+        //Get Home Directory out of user preferences so we can return it later,
+        //necessary for removing directories as done by OC_User.
+        $home = $this->ocConfig->getUserValue($uid, 'user_ldap', 'homePath', '');
+        $this->homesToKill[$uid] = $home;
+        $this->access->getUserMapper()->unmap($uid);
+
+        return true;
+    }
+
+    /**
+     * get the user's home directory
+     *
+     * @param string $uid the username
+     * @return bool|string
+     * @throws NoUserException
+     * @throws \Exception
+     */
+    public function getHome($uid) {
+        if(isset($this->homesToKill[$uid]) && !empty($this->homesToKill[$uid])) {
+            //a deleted user who needs some clean up
+            return $this->homesToKill[$uid];
+        }
+
+        // user Exists check required as it is not done in user proxy!
+        if(!$this->userExists($uid)) {
+            return false;
+        }
+
+        $cacheKey = 'getHome'.$uid;
+        $path = $this->access->connection->getFromCache($cacheKey);
+        if(!is_null($path)) {
+            return $path;
+        }
+
+        $user = $this->access->userManager->get($uid);
+        if(is_null($user) || ($user instanceof OfflineUser && !$this->userExistsOnLDAP($user->getOCName()))) {
+            throw new NoUserException($uid . ' is not a valid user anymore');
+        }
+        if($user instanceof OfflineUser) {
+            // apparently this user survived the userExistsOnLDAP check,
+            // we request the user instance again in order to retrieve a User
+            // instance instead
+            $user = $this->access->userManager->get($uid);
+        }
+        $path = $user->getHomePath();
+        $this->access->cacheUserHome($uid, $path);
+
+        return $path;
+    }
+
+    /**
+     * get display name of the user
+     * @param string $uid user ID of the user
+     * @return string|false display name
+     */
+    public function getDisplayName($uid) {
+        if(!$this->userExists($uid)) {
+            return false;
+        }
+
+        $cacheKey = 'getDisplayName'.$uid;
+        if(!is_null($displayName = $this->access->connection->getFromCache($cacheKey))) {
+            return $displayName;
+        }
+
+        //Check whether the display name is configured to have a 2nd feature
+        $additionalAttribute = $this->access->connection->ldapUserDisplayName2;
+        $displayName2 = '';
+        if ($additionalAttribute !== '') {
+            $displayName2 = $this->access->readAttribute(
+                $this->access->username2dn($uid),
+                $additionalAttribute);
+        }
+
+        $displayName = $this->access->readAttribute(
+            $this->access->username2dn($uid),
+            $this->access->connection->ldapUserDisplayName);
+
+        if($displayName && (count($displayName) > 0)) {
+            $displayName = $displayName[0];
+
+            if (is_array($displayName2)){
+                $displayName2 = count($displayName2) > 0 ? $displayName2[0] : '';
+            }
+
+            $user = $this->access->userManager->get($uid);
+            if ($user instanceof User) {
+                $displayName = $user->composeAndStoreDisplayName($displayName, $displayName2);
+                $this->access->connection->writeToCache($cacheKey, $displayName);
+            }
+            if ($user instanceof OfflineUser) {
+                /** @var OfflineUser $user*/
+                $displayName = $user->getDisplayName();
+            }
+            return $displayName;
+        }
+
+        return null;
+    }
+
+    /**
+     * Get a list of all display names
+     *
+     * @param string $search
+     * @param string|null $limit
+     * @param string|null $offset
+     * @return array an array of all displayNames (value) and the corresponding uids (key)
+     */
+    public function getDisplayNames($search = '', $limit = null, $offset = null) {
+        $cacheKey = 'getDisplayNames-'.$search.'-'.$limit.'-'.$offset;
+        if(!is_null($displayNames = $this->access->connection->getFromCache($cacheKey))) {
+            return $displayNames;
+        }
+
+        $displayNames = array();
+        $users = $this->getUsers($search, $limit, $offset);
+        foreach ($users as $user) {
+            $displayNames[$user] = $this->getDisplayName($user);
+        }
+        $this->access->connection->writeToCache($cacheKey, $displayNames);
+        return $displayNames;
+    }
+
+    /**
+     * Check if backend implements actions
+     * @param int $actions bitwise-or'ed actions
+     * @return boolean
+     *
+     * Returns the supported actions as int to be
+     * compared with OC_USER_BACKEND_CREATE_USER etc.
+     */
+    public function implementsActions($actions) {
+        return (bool)((Backend::CHECK_PASSWORD
+            | Backend::GET_HOME
+            | Backend::GET_DISPLAYNAME
+            | Backend::PROVIDE_AVATAR
+            | Backend::COUNT_USERS
+            | ((intval($this->access->connection->turnOnPasswordChange) === 1)?(Backend::SET_PASSWORD):0))
+            & $actions);
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasUserListings() {
+        return true;
+    }
+
+    /**
+     * counts the users in LDAP
+     *
+     * @return int|bool
+     */
+    public function countUsers() {
+        $filter = $this->access->getFilterForUserCount();
+        $cacheKey = 'countUsers-'.$filter;
+        if(!is_null($entries = $this->access->connection->getFromCache($cacheKey))) {
+            return $entries;
+        }
+        $entries = $this->access->countUsers($filter);
+        $this->access->connection->writeToCache($cacheKey, $entries);
+        return $entries;
+    }
+
+    /**
+     * Backend name to be shown in user management
+     * @return string the name of the backend to be shown
+     */
+    public function getBackendName(){
+        return 'LDAP';
+    }
 	
-	/**
-	 * Return access for LDAP interaction.
-	 * @param string $uid
-	 * @return Access instance of Access for LDAP interaction
-	 */
-	public function getLDAPAccess($uid) {
-		return $this->access;
-	}
+    /**
+     * Return access for LDAP interaction.
+     * @param string $uid
+     * @return Access instance of Access for LDAP interaction
+     */
+    public function getLDAPAccess($uid) {
+        return $this->access;
+    }
 	
-	/**
-	 * Return LDAP connection resource from a cloned connection.
-	 * The cloned connection needs to be closed manually.
-	 * of the current access.
-	 * @param string $uid
-	 * @return resource of the LDAP connection
-	 */
-	public function getNewLDAPConnection($uid) {
-		$connection = clone $this->access->getConnection();
-		return $connection->getConnectionResource();
-	}
+    /**
+     * Return LDAP connection resource from a cloned connection.
+     * The cloned connection needs to be closed manually.
+     * of the current access.
+     * @param string $uid
+     * @return resource of the LDAP connection
+     */
+    public function getNewLDAPConnection($uid) {
+        $connection = clone $this->access->getConnection();
+        return $connection->getConnectionResource();
+    }
 }