LDAPAccountManager/lam/lib/modules.inc

2359 lines
83 KiB
PHP
Raw Normal View History

<?php
2016-12-24 14:39:02 +00:00
use LAM\TYPES\ConfiguredType;
2017-03-30 16:56:23 +00:00
use \LAM\TYPES\TypeManager;
/*
2009-10-27 18:47:12 +00:00
This code is part of LDAP Account Manager (http://www.ldap-account-manager.org/)
2020-03-02 14:20:18 +00:00
Copyright (C) 2003 - 2020 Roland Gruber
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2004-06-20 19:23:04 +00:00
*/
2004-06-20 19:23:04 +00:00
/**
* Interface between modules and other parts of LAM.
2006-08-14 17:29:45 +00:00
*
2004-06-20 19:23:04 +00:00
* @package modules
* @author Tilo Lutz
* @author Michael Duergner
* @author Roland Gruber
*/
2016-01-20 20:48:53 +00:00
/** self service functions */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/selfService.inc");
2016-01-20 20:48:53 +00:00
if (isLAMProVersion()) {
/** job interface */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/jobs.inc");
2016-01-20 20:48:53 +00:00
}
2004-06-20 19:23:04 +00:00
/** some helper functions */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/account.inc");
/** parent class of account modules */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/baseModule.inc");
/** access to LDAP server */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/ldap.inc");
2017-09-16 13:09:25 +00:00
/** remote functions */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/remote.inc");
2006-04-23 16:33:25 +00:00
/** security functions */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/security.inc");
2010-06-06 18:16:09 +00:00
/** meta HTML classes */
2018-12-23 16:52:56 +00:00
include_once(__DIR__ . "/html.inc");
2006-08-14 17:29:45 +00:00
2004-06-20 19:23:04 +00:00
/**
* This includes all module files.
*/
2004-10-14 14:09:44 +00:00
$modulesINC_dirname = substr(__FILE__, 0, strlen(__FILE__) - 12) . "/modules";
$modulesINC_dir = dir($modulesINC_dirname);
// get module names.
2018-12-23 10:11:23 +00:00
while ($entry = $modulesINC_dir->read()) {
if ((substr($entry, strlen($entry) - 4, 4) == '.inc') && is_file($modulesINC_dirname . '/'.$entry)) {
include_once($modulesINC_dirname . '/'.$entry);
}
}
2004-06-14 16:05:36 +00:00
/**
* Returns the alias name of a module
*
* @param string $name the module name
* @param string $scope the account type ("user", "group", "host")
* @return string alias name
*/
function getModuleAlias($name, $scope) {
2013-05-09 19:10:35 +00:00
$module = moduleCache::getModule($name, $scope);
2004-06-14 16:05:36 +00:00
return $module->get_alias();
}
2004-06-20 19:23:04 +00:00
/**
* Returns true if the module is a base module
*
* @param string $name the module name
* @param string $scope the account type ("user", "group", "host")
* @return boolean true if base module
*/
function is_base_module($name, $scope) {
2013-05-09 19:10:35 +00:00
$module = moduleCache::getModule($name, $scope);
return $module->is_base_module();
}
2004-06-20 19:23:04 +00:00
/**
* Returns the LDAP filter used by the account lists
*
2016-12-29 19:12:15 +00:00
* @param string $typeId the account type ("user", "group", "host")
2004-06-20 19:23:04 +00:00
* @return string LDAP filter
*/
2016-12-29 19:12:15 +00:00
function get_ldap_filter($typeId) {
$typeManager = new \LAM\TYPES\TypeManager();
$type = $typeManager->getConfiguredType($typeId);
$mods = $_SESSION['config']->get_AccountModules($typeId);
$filters = array('or' => array(), 'and' => array());
$orFilter = '';
2004-02-23 16:55:51 +00:00
for ($i = 0; $i < sizeof($mods); $i++) {
2016-12-29 19:12:15 +00:00
$module = moduleCache::getModule($mods[$i], $type->getScope());
2017-12-22 08:41:52 +00:00
$modinfo = $module->get_ldap_filter($typeId);
2016-12-29 19:12:15 +00:00
if (isset($modinfo['or'])) {
$filters['or'][] = $modinfo['or'];
}
if (isset($modinfo['and'])) {
$filters['and'][] = $modinfo['and'];
}
2004-02-23 16:55:51 +00:00
}
// build OR filter
if (sizeof($filters['or']) == 1) {
$orFilter = $filters['or'][0];
2004-02-23 16:55:51 +00:00
}
elseif (sizeof($filters['or']) > 1) {
$orFilter = "(|" . implode("", $filters['or']) . ")";
2004-02-23 16:55:51 +00:00
}
// add built OR filter to AND filters
2016-12-29 19:12:15 +00:00
if (!empty($orFilter)) {
$filters['and'][] = $orFilter;
}
// add type filter
$typeSettings = $_SESSION['config']->get_typeSettings();
2016-12-29 19:12:15 +00:00
if (isset($typeSettings['filter_' . $typeId]) && ($typeSettings['filter_' . $typeId] != '')) {
if (strpos($typeSettings['filter_' . $typeId], '(') === 0) {
$filters['and'][] = $typeSettings['filter_' . $typeId];
}
else {
2016-12-29 19:12:15 +00:00
$filters['and'][] = '(' . $typeSettings['filter_' . $typeId] . ')';
}
}
// collapse AND filters
2013-01-27 19:31:32 +00:00
$finalFilter = '';
if (sizeof($filters['and']) < 2) {
$finalFilter = $filters['and'][0];
}
else {
$finalFilter = "(&" . implode("", $filters['and']) . ")";
}
2019-08-05 19:56:06 +00:00
$loginData = $_SESSION['ldap']->getUserName();
return str_replace('@@LOGIN_DN@@', $loginData, $finalFilter);
2004-02-23 16:55:51 +00:00
}
2004-10-06 18:17:22 +00:00
/**
* Returns a list of LDAP attributes which can be used to form the RDN.
*
* The list is already sorted by the priority given by the nodules.
*
2016-12-29 19:12:15 +00:00
* @param string $typeId account type (user, group, host)
* @param array $selectedModules return only RDN attributes of these modules
2004-10-06 18:17:22 +00:00
* @return array list of LDAP attributes
*/
2016-12-29 19:12:15 +00:00
function getRDNAttributes($typeId, $selectedModules=null) {
$mods = $_SESSION['config']->get_AccountModules($typeId);
if ($selectedModules != null) {
$mods = $selectedModules;
}
2004-10-06 18:17:22 +00:00
$return = array();
$attrs_low = array();
$attrs_normal = array();
$attrs_high = array();
for ($i = 0; $i < sizeof($mods); $i++) {
// get list of attributes
2016-12-29 19:12:15 +00:00
$module = moduleCache::getModule($mods[$i], \LAM\TYPES\getScopeFromTypeId($typeId));
2017-06-11 19:15:41 +00:00
$attrs = $module->get_RDNAttributes($typeId);
2004-10-06 18:17:22 +00:00
$keys = array_keys($attrs);
// sort attributes
for ($k = 0; $k < sizeof($keys); $k++) {
switch ($attrs[$keys[$k]]) {
case "low":
$attrs_low[] = $keys[$k];
break;
case "normal":
$attrs_normal[] = $keys[$k];
break;
case "high":
$attrs_high[] = $keys[$k];
break;
default:
$attrs_low[] = $keys[$k];
break;
}
}
}
// merge arrays
$return = array_values(array_unique($attrs_high));
for ($i = 0; $i < sizeof($attrs_normal); $i++) {
2019-08-05 19:56:06 +00:00
if (!in_array($attrs_normal[$i], $return)) {
$return[] = $attrs_normal[$i];
}
}
for ($i = 0; $i < sizeof($attrs_low); $i++) {
2019-01-02 20:10:32 +00:00
if (!in_array($attrs_low[$i], $return)) {
$return[] = $attrs_low[$i];
}
}
2004-10-06 18:17:22 +00:00
return $return;
}
2004-06-20 19:23:04 +00:00
/**
2004-10-17 09:52:58 +00:00
* Returns a hash array (module name => dependencies) of all module dependencies
2004-06-20 19:23:04 +00:00
*
* "dependencies" contains an array with two sub arrays: depends, conflicts
* <br>The elements of "depends" are either module names or an array of module names (OR-case).
* <br>The elements of conflicts are module names.
*
* @param string $scope the account type (user, group, host)
* @return array dependencies
*/
2004-02-08 15:57:55 +00:00
function getModulesDependencies($scope) {
$mods = getAvailableModules($scope);
for ($i = 0; $i < sizeof($mods); $i++) {
2013-05-09 19:10:35 +00:00
$module = moduleCache::getModule($mods[$i], $scope);
2004-06-20 17:32:02 +00:00
$return[$mods[$i]] = $module->get_dependencies();
}
2004-02-07 18:34:26 +00:00
return $return;
}
2004-02-07 18:34:26 +00:00
2004-06-20 19:23:04 +00:00
/**
* Checks if there are missing dependencies between modules.
*
* @param array $selected selected module names
* @param array $deps module dependencies
2020-03-02 14:20:18 +00:00
* @return mixed false if no missing dependency was found,
2004-06-20 19:23:04 +00:00
* otherwise an array of array(selected module, depending module) if missing dependencies were found
*/
function check_module_depends($selected, $deps) {
$ret = array();
for ($m = 0; $m < sizeof($selected); $m++) { // check selected modules
for ($i = 0; $i < sizeof($deps[$selected[$m]]['depends']); $i++) { // check dependencies of module
// check if we have OR-combined modules
if (is_array($deps[$selected[$m]]['depends'][$i])) {
// one of the elements is needed
$found = false;
$depends = $deps[$selected[$m]]['depends'][$i];
for ($d = 0; $d < sizeof($depends); $d++) {
if (in_array($depends[$d], $selected)) {
$found = true;
break;
}
}
if (! $found) {
// missing dependency, add to return value
$ret[] = array($selected[$m], implode(" || ", $depends));
}
}
else {
// single dependency
if (! in_array($deps[$selected[$m]]['depends'][$i], $selected)) {
// missing dependency, add to return value
$ret[] = array($selected[$m], $deps[$selected[$m]]['depends'][$i]);
}
}
}
}
2019-01-02 20:10:32 +00:00
if (sizeof($ret) > 0) {
return $ret;
}
return false;
}
2004-06-20 19:23:04 +00:00
/**
* Checks if there are conflicts between modules
*
* @param array $selected selected module names
* @param array $deps module dependencies
* @return boolean false if no conflict was found,
2004-06-20 19:23:04 +00:00
* otherwise an array of array(selected module, conflicting module) if conflicts were found
*/
function check_module_conflicts($selected, $deps) {
$ret = array();
for ($m = 0; $m < sizeof($selected); $m++) {
for ($i = 0; $i < sizeof($deps[$selected[$m]]['conflicts']); $i++) {
if (in_array($deps[$selected[$m]]['conflicts'][$i], $selected)) {
$ret[] = array($selected[$m], $deps[$selected[$m]]['conflicts'][$i]);
}
}
}
2019-01-02 20:10:32 +00:00
if (sizeof($ret) > 0) {
return $ret;
}
return false;
}
2004-06-13 19:58:58 +00:00
/**
* Returns an array with all available user module names
*
* @param string $scope account type (user, group, host)
* @param boolean $mustSupportAdminInterface module must support LAM admin interface (default: false)
2004-06-13 19:58:58 +00:00
* @return array list of possible modules
*/
function getAvailableModules($scope, $mustSupportAdminInterface = false) {
2004-10-14 14:09:44 +00:00
$dirname = substr(__FILE__, 0, strlen(__FILE__) - 12) . "/modules";
$dir = dir($dirname);
2004-05-23 15:51:21 +00:00
$return = array();
2004-02-07 18:34:26 +00:00
// get module names.
2019-01-02 20:10:32 +00:00
while ($entry = $dir->read()) {
2004-10-14 14:09:44 +00:00
if ((substr($entry, strlen($entry) - 4, 4) == '.inc') && is_file($dirname . '/'.$entry)) {
2004-02-08 15:57:55 +00:00
$entry = substr($entry, 0, strpos($entry, '.'));
2013-05-09 19:10:35 +00:00
$temp = moduleCache::getModule($entry, $scope);
2012-09-26 17:36:22 +00:00
if ($mustSupportAdminInterface && !$temp->supportsAdminInterface()) {
continue;
}
if ($temp->can_manage()) {
$return[] = $entry;
}
}
2019-01-02 20:10:32 +00:00
}
2004-02-07 18:34:26 +00:00
return $return;
2004-05-23 15:51:21 +00:00
}
2004-02-07 18:34:26 +00:00
2004-06-20 19:23:04 +00:00
/**
* Returns the elements for the profile page.
*
2017-03-30 16:56:23 +00:00
* @param string $typeId account type (user, group, host)
2004-06-20 19:23:04 +00:00
* @return array profile elements
*/
2017-03-30 16:56:23 +00:00
function getProfileOptions($typeId) {
$typeManager = new TypeManager();
$type = $typeManager->getConfiguredType($typeId);
$mods = $type->getModules();
$return = array();
for ($i = 0; $i < sizeof($mods); $i++) {
2017-03-30 16:56:23 +00:00
$module = moduleCache::getModule($mods[$i], $type->getScope());
2017-03-30 18:39:24 +00:00
$return[$mods[$i]] = $module->get_profileOptions($typeId);
2004-02-08 15:57:55 +00:00
}
return $return;
2004-04-03 14:47:33 +00:00
}
2004-02-08 15:57:55 +00:00
2004-06-20 19:23:04 +00:00
/**
* Checks if the profile options are valid
*
2017-03-30 18:39:24 +00:00
* @param string $typeId account type (user, group, host)
2004-06-20 19:23:04 +00:00
* @param array $options hash array containing all options (name => array(...))
* @return array list of error messages
*/
2017-03-30 18:39:24 +00:00
function checkProfileOptions($typeId, $options) {
$typeManager = new TypeManager();
$type = $typeManager->getConfiguredType($typeId);
$mods = $type->getModules();
$return = array();
for ($i = 0; $i < sizeof($mods); $i++) {
2017-03-30 18:39:24 +00:00
$module = moduleCache::getModule($mods[$i], $type->getScope());
$temp = $module->check_profileOptions($options, $type->getId());
$return = array_merge($return, $temp);
2004-02-08 15:57:55 +00:00
}
return $return;
2004-03-14 17:35:22 +00:00
}
/**
* Returns a hash array (module name => elements) of all module options for the configuration page.
*
* @param array $scopes hash array (module name => array(account types))
* @return array configuration options
*/
function getConfigOptions($scopes) {
$return = array();
$modules = array_keys($scopes);
for ($i = 0; $i < sizeof($modules); $i++) {
2013-05-09 19:10:35 +00:00
$m = moduleCache::getModule($modules[$i], 'none');
2006-03-06 17:09:17 +00:00
$return[$modules[$i]] = $m->get_configOptions($scopes[$modules[$i]], $scopes);
}
return $return;
}
/**
* Checks if the configuration options are valid
*
2017-12-20 19:44:08 +00:00
* @param array $scopes hash array (module name => array(account type ids))
* @param array $options hash array containing all options (name => array(...))
* @return array list of error messages
*/
function checkConfigOptions($scopes, &$options) {
$return = array();
$modules = array_keys($scopes);
for ($i = 0; $i < sizeof($modules); $i++) {
2013-05-09 19:10:35 +00:00
$m = moduleCache::getModule($modules[$i], 'none');
$errors = $m->check_configOptions($scopes[$modules[$i]], $options);
2007-10-05 18:09:49 +00:00
if (isset($errors) && is_array($errors)) {
$return = array_merge($return, $errors);
}
}
return $return;
}
2004-06-20 19:23:04 +00:00
/**
* Returns a help entry from an account module.
*
* @param string $module module name
2009-02-07 22:57:04 +00:00
* @param string $helpID help identifier
* @param string $scope account type
2004-06-20 19:23:04 +00:00
* @return array help entry
*/
function getHelp($module,$helpID,$scope='') {
2013-12-29 10:31:40 +00:00
global $helpArray;
2009-02-07 19:25:22 +00:00
if (!isset($module) || ($module == '') || ($module == 'main')) {
$helpPath = "../help/help.inc";
2019-01-02 20:10:32 +00:00
if (is_file("../../help/help.inc")) {
$helpPath = "../../help/help.inc";
}
2009-02-07 20:36:56 +00:00
if (!isset($helpArray)) {
2013-12-29 10:31:40 +00:00
include_once($helpPath);
2009-02-07 20:36:56 +00:00
}
2009-02-07 19:25:22 +00:00
return $helpArray[$helpID];
}
2013-05-09 19:10:35 +00:00
if (empty($scope)) {
$scope = 'none';
}
$moduleObject = moduleCache::getModule($module, $scope);
2004-10-30 16:46:06 +00:00
return $moduleObject->get_help($helpID);
2004-03-15 16:30:52 +00:00
}
2004-06-20 19:23:04 +00:00
/**
* Returns a list of available PDF entries.
*
2017-01-04 19:52:51 +00:00
* @param string $typeId account type (user, group, host)
2010-04-05 10:13:37 +00:00
* @return array PDF entries (field ID => field label)
2004-06-20 19:23:04 +00:00
*/
2017-01-04 19:52:51 +00:00
function getAvailablePDFFields($typeId) {
$typeManager = new TypeManager();
$_SESSION['pdfContainer'] = new accountContainer($typeManager->getConfiguredType($typeId), 'pdfContainer');
$_SESSION['pdfContainer']->initModules();
$mods = $_SESSION['pdfContainer']->getAccountModules();
2005-06-19 09:40:30 +00:00
$return = array();
foreach ($mods as $module) {
2017-04-01 07:57:03 +00:00
$fields = $module->get_pdfFields($typeId);
$moduleName = get_class($module);
$return[$moduleName] = array();
2010-04-05 10:13:37 +00:00
if (is_array($fields)) {
foreach ($fields as $fieldID => $fieldLabel) {
if (is_integer($fieldID)) {
// support old PDF field list which did not contain a label
$return[$moduleName][$fieldLabel] = $fieldLabel;
2010-04-05 10:13:37 +00:00
}
else {
$return[$moduleName][$fieldID] = $fieldLabel;
2010-04-05 10:13:37 +00:00
}
}
}
}
2010-04-05 12:38:23 +00:00
$return['main'] = array('dn' => _('DN'));
unset($_SESSION['pdfContainer']);
2005-06-19 09:40:30 +00:00
return $return;
}
/**
* Returns an array containing all input columns for the file upload.
*
* Syntax:
* <br> array(
* <br> string: name, // fixed non-translated name which is used as column name (should be of format: <module name>_<column name>)
* <br> string: description, // short descriptive name
* <br> string: help, // help ID
* <br> string: example, // example value
* <br> boolean: required // true, if user must set a value for this column
* <br> )
*
2017-05-20 08:04:09 +00:00
* @param ConfiguredType $type account type
* @param array $selectedModules selected account modules
* @return array column list
*/
2017-05-20 08:04:09 +00:00
function getUploadColumns(&$type, $selectedModules) {
$return = array();
for ($i = 0; $i < sizeof($selectedModules); $i++) {
2017-05-20 08:04:09 +00:00
$module = moduleCache::getModule($selectedModules[$i], $type->getScope());
2017-05-20 08:55:26 +00:00
$return[$selectedModules[$i]] = $module->get_uploadColumns($selectedModules, $type);
}
return $return;
}
/**
* This function builds the LDAP accounts for the file upload.
*
* If there are problems status messages will be printed automatically.
*
2017-05-20 09:46:49 +00:00
* @param ConfiguredType $type account type
* @param array $data array containing one account in each element
* @param array $ids array(<column_name> => <column number>)
* @param array $selectedModules selected account modules
2018-04-18 17:08:51 +00:00
* @param htmlResponsiveRow $container HTML container
* @return mixed array including accounts or false if there were errors
*/
2018-04-18 17:08:51 +00:00
function buildUploadAccounts($type, $data, $ids, $selectedModules, htmlResponsiveRow $container) {
// build module order
$unOrdered = $selectedModules;
$ordered = array();
$predepends = array();
// get dependencies
for ($i = 0; $i < sizeof($unOrdered); $i++) {
2017-05-20 09:46:49 +00:00
$mod = moduleCache::getModule($unOrdered[$i], $type->getScope());
$predepends[$unOrdered[$i]] = $mod->get_uploadPreDepends();
}
// first all modules without predepends can be ordered
for ($i = 0; $i < sizeof($unOrdered); $i++) {
if (sizeof($predepends[$unOrdered[$i]]) == 0) {
$ordered[] = $unOrdered[$i];
unset($unOrdered[$i]);
$unOrdered = array_values($unOrdered);
$i--;
}
}
$unOrdered = array_values($unOrdered); // fix indexes
// now add all modules with fulfilled dependencies until all are in order
while (sizeof($unOrdered) > 0) {
$newRound = false;
for ($i = 0; $i < sizeof($unOrdered); $i++) {
$deps = $predepends[$unOrdered[$i]];
$depends = false;
for ($d = 0; $d < sizeof($deps); $d++) {
if (in_array($deps[$d], $unOrdered)) {
$depends = true;
break;
}
}
if (!$depends) { // add to order if dependencies are fulfilled
$ordered[] = $unOrdered[$i];
unset($unOrdered[$i]);
$unOrdered = array_values($unOrdered);
$newRound = true;
break;
}
}
2019-01-02 20:10:32 +00:00
if ($newRound) {
continue;
}
// this point should never be reached, LAM was unable to find a correct module order
2018-04-18 17:08:51 +00:00
$container->add(new htmlStatusMessage("ERROR", "Internal Error: Unable to find correct module order."), 12);
return false;
}
// give raw data to modules
$errors = array();
$partialAccounts = array();
2014-09-21 15:06:11 +00:00
foreach ($data as $i => $dataRow) {
$partialAccounts[$i]['objectClass'] = array();
}
2018-05-22 17:55:49 +00:00
$stopUpload = false;
for ($i = 0; $i < sizeof($ordered); $i++) {
2017-05-20 09:46:49 +00:00
$module = new $ordered[$i]($type->getScope());
2018-05-22 17:55:49 +00:00
$moduleErrors = $module->build_uploadAccounts($data, $ids, $partialAccounts, $selectedModules, $type);
if (sizeof($moduleErrors) > 0) {
$errors = array_merge($errors, $moduleErrors);
foreach ($moduleErrors as $error) {
if ($error[0] == 'ERROR') {
array_unshift($errors, array("INFO", _("Displayed account numbers start at \"0\". Add 2 to get the row in your spreadsheet."), ""));
$errors[] = array("ERROR", _("Upload was stopped after errors in %s module!"), "", array($module->get_alias()));
// skip other modules if error was found
$stopUpload = true;
break;
}
}
}
if ($stopUpload) {
2004-09-19 16:04:37 +00:00
break;
}
}
2004-09-19 16:04:37 +00:00
if (sizeof($errors) > 0) {
2018-12-23 09:33:15 +00:00
for ($i = 0; (($i < sizeof($errors)) && ($i < 50)); $i++) {
2018-04-18 17:08:51 +00:00
$text = empty($errors[$i][2]) ? null : $errors[$i][2];
$values = empty($errors[$i][3]) ? null : $errors[$i][3];
$container->add(new htmlStatusMessage($errors[$i][0], $errors[$i][1], $text, $values), 12);
2017-09-18 17:47:27 +00:00
}
2018-05-22 17:55:49 +00:00
}
if ($stopUpload) {
2004-09-19 16:04:37 +00:00
return false;
}
2017-09-18 17:47:27 +00:00
return $partialAccounts;
}
2012-10-06 16:37:36 +00:00
/**
* Runs any actions that need to be done before an LDAP entry is created.
2015-06-24 17:40:20 +00:00
*
2017-09-02 11:03:36 +00:00
* @param ConfiguredType $type account type
2012-10-06 16:37:36 +00:00
* @param array $selectedModules list of selected account modules
* @param array $attributes LDAP attributes of this entry (attributes are provided as reference, handle modifications of $attributes with care)
* @return array array which contains status messages. Each entry is an array containing the status message parameters.
*/
2017-09-02 11:03:36 +00:00
function doUploadPreActions($type, $selectedModules, $attributes) {
2012-10-06 16:37:36 +00:00
$messages = array();
for ($i = 0; $i < sizeof($selectedModules); $i++) {
$activeModule = $selectedModules[$i];
2017-09-02 11:03:36 +00:00
$module = moduleCache::getModule($activeModule, $type->getScope());
$messages = array_merge($messages, $module->doUploadPreActions($attributes, $type));
2012-10-06 16:37:36 +00:00
}
return $messages;
}
2004-10-19 18:18:46 +00:00
/**
* This function executes one post upload action.
*
2017-09-02 11:03:36 +00:00
* @param ConfiguredType $type account type
2004-10-19 18:18:46 +00:00
* @param array $data array containing one account in each element
* @param array $ids array(<column_name> => <column number>)
* @param array $failed list of accounts which were not created successfully
* @param array $selectedModules list of selected account modules
2010-12-16 17:59:04 +00:00
* @param array $accounts list of LDAP entries
2004-10-19 18:18:46 +00:00
* @return array current status
* <br> array (
* <br> 'status' => 'finished' | 'inProgress'
* <br> 'module' => <name of active module>
* <br> 'progress' => 0..100
* <br> 'errors' => array (<array of parameters for StatusMessage>)
* <br> )
*/
2017-09-02 11:03:36 +00:00
function doUploadPostActions($type, &$data, $ids, $failed, $selectedModules, &$accounts) {
2004-10-19 18:18:46 +00:00
// check if function is called the first time
if (! isset($_SESSION['mass_postActions']['remainingModules'])) {
// make list of remaining modules
$moduleList = $selectedModules;
2004-10-19 18:18:46 +00:00
$_SESSION['mass_postActions']['remainingModules'] = $moduleList;
}
$activeModule = $_SESSION['mass_postActions']['remainingModules'][0];
// initialize temporary variable
if (!isset($_SESSION['mass_postActions'][$activeModule])) {
$_SESSION['mass_postActions'][$activeModule] = array();
}
// let first module do one post action
2017-09-02 11:03:36 +00:00
$module = moduleCache::getModule($activeModule, $type->getScope());
$return = $module->doUploadPostActions($data, $ids, $failed, $_SESSION['mass_postActions'][$activeModule], $accounts, $selectedModules, $type);
2004-10-19 18:18:46 +00:00
// remove active module from list if already finished
if ($return['status'] == 'finished') {
unset($_SESSION['mass_postActions']['remainingModules'][0]);
$_SESSION['mass_postActions']['remainingModules'] = array_values($_SESSION['mass_postActions']['remainingModules']);
}
// update status and return back to upload page
$return['module'] = $activeModule;
if (sizeof($_SESSION['mass_postActions']['remainingModules']) > 0) {
$return['status'] = 'inProgress';
}
else {
$return['status'] = 'finished';
}
return $return;
}
2006-04-29 09:58:17 +00:00
/**
* Returns true if the module is a base module
*
* @return array required extensions
*/
function getRequiredExtensions() {
$extList = array();
2016-12-29 19:12:15 +00:00
$typeManager = new \LAM\TYPES\TypeManager();
$types = $typeManager->getConfiguredTypes();
foreach ($types as $type) {
$mods = $_SESSION['config']->get_AccountModules($type->getId());
2006-04-29 09:58:17 +00:00
for ($m = 0; $m < sizeof($mods); $m++) {
2016-12-29 19:12:15 +00:00
$module = moduleCache::getModule($mods[$m], $type->getScope());
2006-04-29 09:58:17 +00:00
$ext = $module->getRequiredExtensions();
for ($e = 0; $e < sizeof($ext); $e++) {
2016-12-29 19:12:15 +00:00
if (!in_array($ext[$e], $extList)) {
$extList[] = $ext[$e];
}
2006-04-29 09:58:17 +00:00
}
}
}
return $extList;
}
/**
* Takes a list of meta-HTML elements and prints the equivalent HTML output.
2015-06-24 17:40:20 +00:00
*
2008-02-07 19:05:44 +00:00
* The modules are not allowed to display HTML code directly but return
2011-04-28 17:42:47 +00:00
* meta HTML code. This allows to have a common design for all module pages.
*
* @param string $module Name of account module
2010-10-24 13:53:22 +00:00
* @param mixed $input htmlElement or array of htmlElement elements
* @param array $values List of values which override the defaults in $input (name => value)
* @param boolean $restricted If true then no buttons will be displayed
* @param integer $tabindex Start value of tabulator index for input fields
* @param string $scope Account type
* @return array List of input field names and their type (name => type)
*/
2009-02-07 19:25:22 +00:00
function parseHtml($module, $input, $values, $restricted, &$tabindex, $scope) {
2010-05-23 10:35:33 +00:00
if ($input instanceof htmlElement) {
2010-06-06 18:16:09 +00:00
return $input->generateHTML($module, $input, $values, $restricted, $tabindex, $scope);
2010-05-23 10:35:33 +00:00
}
2010-06-10 15:36:43 +00:00
if (is_array($input) && (sizeof($input) > 0)) {
2011-04-28 17:42:47 +00:00
$return = array();
for ($i = 0; $i < sizeof($input); $i++) {
$return = array_merge($return, $input[$i]->generateHTML($module, $input, $values, $restricted, $tabindex, $scope));
}
2011-04-28 17:42:47 +00:00
return $return;
}
2011-04-28 17:42:47 +00:00
return array();
}
2004-10-19 18:18:46 +00:00
2010-01-30 13:56:32 +00:00
/**
* Helper function to sort descriptive options in parseHTML().
* It compares the second entries of two arrays.
*
* @param array $a first array
* @param array $b second array
* @return integer compare result
*/
function lamCompareDescriptiveOptions(&$a, &$b) {
// check parameters
if (!is_array($a) || !isset($a[1]) || !is_array($b) || !isset($b[1])) {
return 0;
}
return strnatcasecmp($a[1], $b[1]);
}
2009-02-07 19:25:22 +00:00
/**
* Prints a LAM help link.
*
* @param array $entry help entry
* @param String $number help number
* @param String $module module name
* @param String $scope account scope
2015-08-09 13:18:04 +00:00
* @param array $classes CSS classes
2009-02-07 19:25:22 +00:00
*/
2015-08-09 13:18:04 +00:00
function printHelpLink($entry, $number, $module = '', $scope = '', $classes = array()) {
2009-02-07 19:25:22 +00:00
$helpPath = "../";
2019-01-02 20:10:32 +00:00
if (is_file("./help.php")) {
$helpPath = "";
}
2009-02-07 19:25:22 +00:00
$title = $entry['Headline'];
$message = $entry['Text'];
if (isset($entry['attr'])) {
$message .= '<br><br><hr class="dotted">' . _('Technical name') . ': <i>' . $entry['attr'] . '</i>';
}
2009-02-15 10:15:29 +00:00
// replace special characters
2013-11-23 14:39:41 +00:00
$message = htmlspecialchars($message);
$title = htmlspecialchars($title);
2017-08-20 17:40:11 +00:00
$selfServiceOption = '';
if (isSelfService()) {
$selfServiceOption = '&amp;selfService=1';
}
echo "<a class=\"margin2 " . implode(" ", $classes) . "\" href=\"" . $helpPath . "help.php?module=$module&amp;HelpNumber=". $number . "&amp;scope=" . $scope . $selfServiceOption . "\" ";
2013-10-20 18:07:56 +00:00
echo "target=\"help\">";
2019-08-15 12:36:55 +00:00
echo "<img helptitle=\"" . $title . "\" helpdata=\"" . $message . "\" class=\"align-middle help-icon\" src=\"../${helpPath}graphics/help.png\" alt=\"" . _('Help') . "\">";
2009-02-07 19:25:22 +00:00
echo "</a>";
}
2006-03-14 17:58:52 +00:00
2004-06-20 19:23:04 +00:00
/**
* This class includes all modules and attributes of an account.
*
* @package modules
*/
2004-02-07 18:34:26 +00:00
class accountContainer {
2015-06-24 17:40:20 +00:00
/**
* Constructor
*
2016-12-24 14:39:02 +00:00
* @param ConfiguredType $type account type
* @param string $base key in $_SESSION where this object is saved
*/
2019-05-20 16:06:07 +00:00
function __construct($type, $base) {
2019-01-02 20:10:32 +00:00
if (!($type instanceof ConfiguredType)) {
trigger_error('Argument of accountContainer must be ConfiguredType.', E_USER_ERROR);
}
if (!is_string($base)) {
trigger_error('Argument of accountContainer must be string.', E_USER_ERROR);
}
2004-02-07 18:34:26 +00:00
$this->type = $type;
$this->base = $base;
2004-09-08 10:07:25 +00:00
// Set startpage
$this->current_page=0;
$this->subpage='attributes';
$this->isNewAccount = false;
2004-02-07 18:34:26 +00:00
return 0;
}
2004-02-07 18:34:26 +00:00
/**
* Array of all used attributes
2004-02-07 18:34:26 +00:00
* Syntax is attribute => array ( objectClass => MUST or MAY, ...)
*/
2009-10-30 18:21:57 +00:00
public $attributes;
2006-08-14 17:29:45 +00:00
/**
* This variale stores the account type.
* Currently "user", "group" and "host" are supported.
2004-02-07 18:34:26 +00:00
*/
2007-10-04 16:45:05 +00:00
private $type;
2006-08-14 17:29:45 +00:00
/** This is an array with all module objects */
2007-10-04 16:45:05 +00:00
private $module;
2006-08-14 17:29:45 +00:00
2005-05-02 17:41:09 +00:00
/** DN suffix of the account */
public $dnSuffix;
2006-08-14 17:29:45 +00:00
/** DN of account when it was loaded */
2009-10-30 18:21:57 +00:00
public $dn_orig;
2006-08-14 17:29:45 +00:00
2005-05-02 17:41:09 +00:00
/** RDN attribute of this account */
2009-10-30 18:21:57 +00:00
public $rdn;
2015-06-24 17:40:20 +00:00
2008-02-23 10:23:40 +00:00
/** DN of saved account */
public $finalDN;
2006-08-14 17:29:45 +00:00
2005-05-02 17:41:09 +00:00
/** original LDAP attributes when account was loaded from LDAP */
2009-10-30 18:21:57 +00:00
public $attributes_orig;
2006-08-14 17:29:45 +00:00
/** Module order */
2007-10-04 16:45:05 +00:00
private $order;
2006-08-14 17:29:45 +00:00
/** Name of accountContainer variable in session */
2007-10-03 18:25:55 +00:00
private $base;
2006-08-14 17:29:45 +00:00
2011-09-23 09:44:38 +00:00
/** This variable stores the page number of the currently displayed page */
private $current_page = 0;
2006-08-14 17:29:45 +00:00
/** This variable is set to the pagename of a subpage if it should be displayed */
2007-10-04 16:45:05 +00:00
private $subpage;
2006-08-14 17:29:45 +00:00
/** True if this is a newly created account */
2008-02-23 10:23:40 +00:00
public $isNewAccount;
2015-06-24 17:40:20 +00:00
2010-11-21 14:32:54 +00:00
/** name of last loaded account profile */
2007-12-04 15:58:05 +00:00
private $lastLoadedProfile = '';
2015-06-24 17:40:20 +00:00
2010-11-21 14:32:54 +00:00
/** cache for existing OUs */
private $cachedOUs = null;
2015-06-24 17:40:20 +00:00
/** main title in title bar */
private $titleBarTitle = null;
/** subtitle in title bar */
private $titleBarSubtitle = null;
/** send password via mail */
private $sendPasswordViaMail = null;
/** send password via mail to this alternate address */
private $sendPasswordViaMailAlternateAddress = null;
2015-06-24 17:40:20 +00:00
2004-02-07 18:34:26 +00:00
2007-10-01 17:46:55 +00:00
/**
* Returns the account module with the given class name
*
* @param string $name class name (e.g. posixAccount)
2007-10-10 16:45:30 +00:00
* @return baseModule account module
2007-10-01 17:46:55 +00:00
*/
2019-08-31 09:15:49 +00:00
public function getAccountModule($name) {
2007-10-01 17:46:55 +00:00
if (isset($this->module[$name])) {
return $this->module[$name];
}
else {
return null;
}
2007-10-26 14:10:10 +00:00
}
2015-06-24 17:40:20 +00:00
2007-10-26 14:10:10 +00:00
/**
* Returns the included account modules.
*
* @return baseModule[] modules
2007-10-26 14:10:10 +00:00
*/
2019-08-31 09:15:49 +00:00
public function getAccountModules() {
2007-10-26 14:10:10 +00:00
return $this->module;
}
2015-06-24 17:40:20 +00:00
/**
2020-03-02 14:20:18 +00:00
* Returns the account type of this object (e.g. user, group, host).
*
2016-12-24 14:39:02 +00:00
* @return ConfiguredType account type
2004-02-07 18:34:26 +00:00
*/
2019-08-31 09:15:49 +00:00
public function get_type() {
2004-02-07 18:34:26 +00:00
return $this->type;
2016-12-31 10:00:47 +00:00
}
2006-08-14 17:29:45 +00:00
/**
* This function is called when the user clicks on any button on the account pages.
* It prints the HTML code of each account page.
*/
2019-08-31 09:15:49 +00:00
public function continue_main() {
2013-05-01 16:55:59 +00:00
$oldPage = $this->current_page;
$oldSubpage = $this->subpage;
2006-08-27 14:57:22 +00:00
$result = array();
2007-12-26 18:49:04 +00:00
$errorsOccured = false;
2016-12-24 14:39:02 +00:00
$typeObject = $this->type->getBaseType();
$profileLoaded = $this->loadProfileIfRequested();
2019-01-02 20:10:32 +00:00
if ($this->subpage == '') {
$this->subpage='attributes';
}
2007-12-26 18:49:04 +00:00
if (isset($_POST['accountContainerReset'])) {
2006-09-16 13:26:18 +00:00
$result = $this->load_account($this->dn_orig);
}
2019-08-31 09:15:49 +00:00
elseif (isset($_POST['accountContainerDelete'])) {
metaRefresh("../lists/deletelink.php?type=" . $this->type->getId() . "&DN='" . rawurlencode($this->dn_orig) . "'");
unset($_SESSION[$this->base]);
exit();
}
elseif (!$profileLoaded) {
2007-12-03 13:01:17 +00:00
// change dn suffix
if (isset($_GET['suffix']) && ($_GET['suffix'] != '') && ($this->dnSuffix == null)) {
$this->dnSuffix = $_GET['suffix'];
2007-12-26 18:49:04 +00:00
}
2011-05-14 13:51:08 +00:00
if (isset($_POST['accountContainerSuffix']) && ($_POST['accountContainerSuffix'] != '')) {
$this->dnSuffix = $_POST['accountContainerSuffix'];
}
2007-12-09 19:39:09 +00:00
// change RDN
2007-12-26 18:49:04 +00:00
if (isset($_POST['accountContainerRDN'])) {
$this->rdn = $_POST['accountContainerRDN'];
}
// create another account
if (isset($_POST['accountContainerCreateAgain'])) {
// open fresh account page
unset($_SESSION[$this->base]);
2018-11-25 09:51:39 +00:00
metaRefresh("edit.php?type=" . $this->type->getId() . "&suffix=" . $this->dnSuffix);
2007-12-26 18:49:04 +00:00
exit();
}
2011-05-03 16:15:38 +00:00
// reedit account
if (isset($_POST['accountContainerBackToEdit'])) {
// open fresh account page
unset($_SESSION[$this->base]);
2018-11-25 09:51:39 +00:00
metaRefresh("edit.php?type=" . $this->type->getId() . "&DN=" . urlencode($this->finalDN));
2011-05-03 16:15:38 +00:00
exit();
}
2007-12-26 18:49:04 +00:00
// back to account list
if (isset($_POST['accountContainerBackToList'])) {
// Return to account list
unset($_SESSION[$this->base]);
2018-11-25 09:51:39 +00:00
metaRefresh("../lists/list.php?type=" . $this->type->getId() . '&accountEditBack=true');
2007-12-26 18:49:04 +00:00
exit;
}
// create PDF file
if (isset($_POST['accountContainerCreatePDF'])) {
2018-11-25 09:51:39 +00:00
metaRefresh('../lists/list.php?printPDF=1&type=' . $this->type->getId() . "&refresh=true&PDFSessionID=" . $this->base);
2007-12-26 18:49:04 +00:00
exit;
}
// module actions
2016-12-24 14:39:02 +00:00
if ((sizeof($_POST) > 0) && checkIfWriteAccessIsAllowed($this->type->getId())) {
2007-12-26 18:49:04 +00:00
$result = call_user_func(array(&$this->module[$this->order[$this->current_page]], 'process_'.$this->subpage));
if (is_array($result)) { // messages were returned, check for errors
for ($i = 0; $i < sizeof($result); $i++) {
if ($result[$i][0] == 'ERROR') {
$errorsOccured = true;
break;
2005-05-10 16:51:32 +00:00
}
2004-09-08 10:07:25 +00:00
}
}
2012-04-09 13:20:24 +00:00
$this->sortModules();
2004-02-07 18:34:26 +00:00
}
2012-04-09 13:20:24 +00:00
// run type post actions
$typeObject->runEditPagePostAction($this);
2007-12-26 18:49:04 +00:00
// save account
if (!$errorsOccured && isset($_POST['accountContainerSaveAccount'])) {
// check if all modules are complete
2007-12-04 15:58:05 +00:00
$modules = array_keys($this->module);
2007-12-26 18:49:04 +00:00
$incompleteModules = array();
foreach ($modules as $module) {
if (!$this->module[$module]->module_complete()) {
$incompleteModules[] = $this->module[$module]->get_alias();
2007-12-04 15:58:05 +00:00
}
}
2007-12-26 18:49:04 +00:00
if (sizeof($incompleteModules) > 0) {
2011-11-01 12:17:44 +00:00
$result[] = array('INFO', _('Some required information is missing'),
2007-12-26 18:49:04 +00:00
sprintf(_('Please set up all required attributes on page: %s'), implode(", ", $incompleteModules)));
}
else {
// save account
2012-01-04 19:08:19 +00:00
$saveMessages = $this->save_account();
$saveOk = true;
for ($i = 0; $i < sizeof($saveMessages); $i++) {
if ($saveMessages[$i][0] == 'ERROR') {
$saveOk = false;
}
}
if (!$saveOk) {
$result = $saveMessages;
2007-12-26 18:49:04 +00:00
}
else {
2012-01-04 19:08:19 +00:00
$this->printSuccessPage($saveMessages);
2007-12-26 18:49:04 +00:00
return;
}
2007-12-04 15:58:05 +00:00
}
}
}
// change to next page
if (is_array($result)) { // messages were returned, check for errors
2006-08-16 17:42:35 +00:00
for ($i = 0; $i < sizeof($result); $i++) {
if ($result[$i][0] == 'ERROR') {
$errorsOccured = true;
break;
}
}
}
if (!$errorsOccured) {
// go to subpage of current module
2006-08-14 17:29:45 +00:00
$postKeys = array_keys($_POST);
for ($p = 0; $p < sizeof($postKeys); $p++) {
if (is_string($postKeys[$p]) && (strpos($postKeys[$p], 'form_subpage_' . $this->order[$this->current_page]) === 0)) {
$temp = substr($postKeys[$p], strlen($this->order[$this->current_page]) + 14);
$temp = explode('_', $temp);
if (sizeof($temp) == 2) {
$this->subpage = $temp[0];
}
}
}
2007-12-26 18:49:04 +00:00
for ($i=0; $i<count($this->order); $i++ ) {
if (isset($_POST['form_main_'.$this->order[$i]])) {
if ($this->module[$this->order[$i]]->module_ready()) {
$this->current_page = $i;
$this->subpage='attributes';
}
else {
StatusMessage('ERROR', _('The module %s is not yet ready.'),
_('Please enter the account information on the other pages first.'),
array($this->module[$this->order[$i]]->get_alias()));
}
}
}
}
if ($profileLoaded) {
$profileName = $_POST['accountContainerSelectLoadProfile'];
$result[] = array('INFO', _('Profile "%s" loaded.'), '<div class="hidden lam-dialog-msg" id="lam-make-default-profile-dlg">' . _('Setting saved') . '</div>' .
'<a href="#" id="lam-make-default-profile" data-name="%s" data-typeid="%s" data-ok="%s">' . _('Click here to make this your default profile.') . '</a>', array($profileName, $profileName, $this->get_type()->getId(), _('Ok')));
}
// update titles
$this->titleBarTitle = $typeObject->getTitleBarTitle($this);
$this->titleBarSubtitle = $typeObject->getTitleBarSubtitle($this);
// prints a module content page
2019-08-31 09:07:06 +00:00
$this->printModuleContent($result);
2013-05-01 16:55:59 +00:00
if (!$errorsOccured && ($oldPage == $this->current_page) && ($oldSubpage == $this->subpage)
&& isset($_POST['scrollPositionTop']) && isset($_POST['scrollPositionLeft'])) {
// scroll to last position
echo '<script type="text/javascript">
jQuery(document).ready(function() {
jQuery(window).scrollTop(' . $_POST['scrollPositionTop'] . ');
jQuery(window).scrollLeft('. $_POST['scrollPositionLeft'] . ');
});
</script>';
}
$this->printPageFooter();
}
2015-06-24 17:40:20 +00:00
/**
* Prints the content part provided by the current module.
2015-06-24 17:40:20 +00:00
*
* @param array $result list of messages
*/
2019-08-31 09:07:06 +00:00
private function printModuleContent($result) {
$tabindex = 1;
2007-12-26 18:49:04 +00:00
$this->printPageHeader();
2011-05-15 18:26:28 +00:00
$this->printPasswordPromt();
// display error messages
2005-05-10 16:51:32 +00:00
if (is_array($result)) {
2006-08-16 17:42:35 +00:00
for ($i=0; $i<sizeof($result); $i++) {
call_user_func_array("StatusMessage", $result[$i]);
2005-05-10 16:51:32 +00:00
}
}
2011-05-15 18:26:28 +00:00
echo '<div id="passwordMessageArea"></div>';
2016-12-24 14:39:02 +00:00
echo "<table class=\"".$this->type->getScope()."-bright\" border=0 width=\"100%\" style=\"border-collapse: collapse;\">\n";
if (checkIfWriteAccessIsAllowed($this->type->getId())) {
2019-11-07 16:21:59 +00:00
echo "<tr class=\"" . $this->type->getScope() . "-bright\"><td style=\"padding: 5px 0px 0px 0px;\">\n";
$this->printCommonControls($tabindex);
2010-09-04 13:52:03 +00:00
echo "</td></tr>\n";
2007-12-11 18:52:07 +00:00
}
2016-12-24 14:39:02 +00:00
echo "<tr class=\"" . $this->type->getScope() . "-bright\" valign=\"top\"><td style=\"padding: 15px;\">";
// print title bar
2019-02-23 17:42:21 +00:00
$titleBarContainer = new htmlResponsiveRow();
$titleBarContainer->setCSSClasses(array('maxrow'));
$titleBarTitleText = new htmlOutputText($this->titleBarTitle, false);
2019-11-07 20:45:12 +00:00
$titleBarContainer->add(new htmlDiv(null, $titleBarTitleText, array('titleBarTitle', 'text-left')), 12, 12, 4);
2019-02-23 17:42:21 +00:00
$titleBarSubtitleText = new htmlOutputText($this->titleBarSubtitle, false);
2019-11-07 20:45:12 +00:00
$titleBarContainer->add(new htmlDiv(null, $titleBarSubtitleText, array('titleBarSubtitle', 'responsiveLabel')), 12, 12, 8);
2019-02-23 17:42:21 +00:00
$titleBarSuffixRdn = new htmlResponsiveRow();
2019-08-15 13:11:25 +00:00
$titleBarSuffixRdn->add(new htmlHorizontalLine(), 12);
2019-02-23 17:42:21 +00:00
// suffix
$suffixList = array();
foreach ($this->getOUs() as $suffix) {
$suffixList[getAbstractDN($suffix)] = $suffix;
}
2019-02-23 17:42:21 +00:00
if (!($this->dnSuffix == '') && !in_array($this->dnSuffix, $this->getOUs())) {
$suffixList[getAbstractDN($this->dnSuffix)] = $this->dnSuffix;
}
$selectedSuffix = array($this->dnSuffix);
2019-10-26 15:52:17 +00:00
$suffixSelect = new htmlResponsiveSelect('accountContainerSuffix', $suffixList, $selectedSuffix, _('Suffix'));
2019-02-23 17:42:21 +00:00
$suffixSelect->setHasDescriptiveElements(true);
$suffixSelect->setRightToLeftTextDirection(true);
2019-11-02 10:35:54 +00:00
$suffixSelect->setShortLabel();
$titleBarSuffixRdn->add($suffixSelect, 12, 12, 7);
2019-02-23 17:42:21 +00:00
// RDN selection
$rdnlist = getRDNAttributes($this->type->getId());
2019-10-26 15:52:17 +00:00
$rdnSelect = new htmlResponsiveSelect('accountContainerRDN', $rdnlist, array($this->rdn), _('RDN identifier'), '400');
2019-11-02 10:35:54 +00:00
$rdnSelect->setShortLabel();
$titleBarSuffixRdn->add($rdnSelect, 12, 12, 5);
2019-02-23 17:42:21 +00:00
$titleBarContainer->add($titleBarSuffixRdn, 12);
$titleBarDiv = new htmlDiv(null, $titleBarContainer, array('titleBar', 'ui-corner-top'));
parseHtml(null, $titleBarDiv, array(), false, $tabindex, $this->type->getScope());
echo '<div id="lamVerticalTabs" class="ui-tabs ui-widget ui-widget-content ui-corner-bottom ui-helper-clearfix">';
2019-09-02 16:05:05 +00:00
echo '<table class="fullwidth">';
2019-08-15 12:13:10 +00:00
echo '<tr><td style="vertical-align: top;">';
2015-12-20 19:07:04 +00:00
// tab menu
$this->printModuleTabs();
2019-09-02 16:05:05 +00:00
echo '</td><td style="vertical-align: top;" width="100%">';
echo "<div class=\"ui-tabs-panel ui-widget-content ui-corner-bottom fullwidth module-content-row\">\n";
2015-12-20 19:07:04 +00:00
// content area
// display html-code from modules
$return = call_user_func(array($this->module[$this->order[$this->current_page]], 'display_html_'.$this->subpage));
$y = 5000;
2016-12-24 14:39:02 +00:00
parseHtml($this->order[$this->current_page], $return, array(), false, $y, $this->type->getScope());
2015-12-20 19:07:04 +00:00
echo "</div>\n";
echo '</td>';
echo '</tr>';
echo '</table>';
2010-09-04 13:52:03 +00:00
echo "</div>\n";
echo "</td></tr>\n";
2007-12-26 18:49:04 +00:00
// Display rest of html-page
2010-09-04 13:52:03 +00:00
echo "</table>\n";
2007-12-26 18:49:04 +00:00
}
/**
* Prints the input fields of the central password service.
*/
2011-05-15 18:26:28 +00:00
private function printPasswordPromt() {
echo "<div id=\"passwordDialog\" class=\"hidden\">\n";
echo '<div id="passwordDialogMessageArea"></div>';
2011-08-28 11:26:51 +00:00
$printContainer = false;
2010-10-11 16:04:17 +00:00
$container = new htmlTable();
// password fields
$container->addElement(new htmlOutputText(_('Password')));
$pwdInput1 = new htmlInputField('newPassword1');
$pwdInput1->setIsPassword(true, true);
$container->addElement($pwdInput1);
$container->addElement(new htmlHelpLink('404'), true);
$container->addElement(new htmlOutputText(_('Repeat password')));
$pwdInput2 = new htmlInputField('newPassword2');
$pwdInput2->setIsPassword(true);
$pwdInput2->setSameValueFieldID('newPassword1');
$container->addElement($pwdInput2, true);
// print force password change option
2018-04-15 08:42:02 +00:00
$forceChangeSupported = array();
foreach ($this->module as $name => $module) {
if (($module instanceof passwordService) && $module->supportsForcePasswordChange()) {
2018-04-15 08:42:02 +00:00
$forceChangeSupported[] = $module;
}
}
2018-04-15 08:42:02 +00:00
if (!empty($forceChangeSupported)) {
$container->addElement(new htmlOutputText(_('Force password change')));
$forcePwdGroup = new htmlGroup();
$forcePwdGroup->addElement(new htmlInputCheckbox('lamForcePasswordChange', false));
$forcePwdGroup->addElement(new htmlSpacer('1rem', null));
foreach ($forceChangeSupported as $module) {
$forcePwdGroup->addElement(new htmlImage('../../graphics/' . $module->getIcon(), '16px', '16px', $module->get_alias(), $module->get_alias()));
2018-04-15 08:46:20 +00:00
$forcePwdGroup->addElement(new htmlSpacer('0.1rem', null));
2018-04-15 08:42:02 +00:00
}
$container->addElement($forcePwdGroup);
$container->addElement(new htmlHelpLink('406'), true);
}
2013-12-29 18:10:26 +00:00
if (isLAMProVersion() && (isset($this->attributes_orig['mail'][0]) || $this->anyModuleManagesMail())) {
$pwdMailCheckbox = new htmlTableExtendedInputCheckbox('lamPasswordChangeSendMail', false, _('Send via mail'));
$pwdMailCheckbox->setTableRowsToShow(array('lamPasswordChangeSendMailAddress'));
$container->addElement($pwdMailCheckbox);
$container->addElement(new htmlHelpLink('407'), true);
2018-12-28 10:19:15 +00:00
if ($_SESSION['config']->getLamProMailAllowAlternateAddress() != 'false') {
$alternateMail = '';
$pwdResetModule = $this->getAccountModule('passwordSelfReset');
if (!empty($pwdResetModule)) {
$backupMail = $pwdResetModule->getBackupEmail();
if (!empty($backupMail)) {
$alternateMail = $pwdResetModule->getBackupEmail();
}
}
$container->addElement(new htmlTableExtendedInputField(_('Alternate recipient'), 'lamPasswordChangeSendMailAddress', $alternateMail, '410'));
2014-02-10 19:16:37 +00:00
}
}
$container->addElement(new htmlSpacer(null, '10px'), true);
2010-10-11 16:04:17 +00:00
// password modules
$moduleContainer = new htmlTable();
foreach ($this->module as $name => $module) {
if (($module instanceof passwordService) && $module->managesPasswordAttributes()) {
2011-08-28 11:26:51 +00:00
$printContainer = true;
$buttonImage = $module->getIcon();
if ($buttonImage != null) {
if (!(strpos($buttonImage, 'http') === 0) && !(strpos($buttonImage, '/') === 0)) {
$buttonImage = '../../graphics/' . $buttonImage;
}
2016-12-24 14:39:02 +00:00
$moduleContainer->addElement(new htmlImage($buttonImage, null, null, getModuleAlias($name, $this->type->getScope())));
}
2016-12-24 14:39:02 +00:00
$moduleContainer->addElement(new htmlTableExtendedInputCheckbox('password_cb_' . $name, true, getModuleAlias($name, $this->type->getScope()), null, false));
2010-10-11 16:04:17 +00:00
$moduleContainer->addElement(new htmlSpacer('10px', null));
}
}
2010-10-11 16:04:17 +00:00
$moduleContainer->colspan = 5;
$container->addElement($moduleContainer, true);
// generate HTML
2011-05-15 18:26:28 +00:00
$tabindex = 2000;
2011-08-28 11:26:51 +00:00
if ($printContainer) {
2016-12-24 14:39:02 +00:00
parseHtml(null, $container, array(), false, $tabindex, $this->type->getScope());
2011-08-28 11:26:51 +00:00
}
2010-10-11 16:04:17 +00:00
echo "</div>\n";
}
2015-06-24 17:40:20 +00:00
/**
* Sets the new password in all selected account modules.
2015-06-24 17:40:20 +00:00
*
2011-05-15 18:26:28 +00:00
* @param array $input input parameters
*/
2011-05-15 18:26:28 +00:00
public function setNewPassword($input) {
$password1 = $input['password1'];
$password2 = $input['password2'];
$random = $input['random'];
$modules = $input['modules'];
for ($m = 0; $m < sizeof($modules); $m++) {
$modules[$m] = str_replace('password_cb_', '', $modules[$m]);
}
$return = array(
'messages' => '',
'errorsOccured' => 'false'
);
if ($random == 'true') {
$password1 = generateRandomPassword();
2012-03-20 20:59:34 +00:00
$return['messages'] .= StatusMessage('INFO', _('The password was set to:') . ' ' . htmlspecialchars($password1), '', array(), true);
}
else {
// check if passwords match
2011-05-15 18:26:28 +00:00
if ($password1 != $password2) {
$return['messages'] .= StatusMessage('ERROR', _('Passwords are different!'), '', array(), true);
$return['errorsOccured'] = 'true';
}
2020-03-02 14:20:18 +00:00
// check passsword strength
2014-04-17 19:26:08 +00:00
$pwdPolicyResult = checkPasswordStrength($password1, null, null);
if ($pwdPolicyResult !== true) {
2011-05-15 18:26:28 +00:00
$return['messages'] .= StatusMessage('ERROR', $pwdPolicyResult, '', array(), true);
$return['errorsOccured'] = 'true';
}
}
2012-02-18 13:47:31 +00:00
$forcePasswordChange = false;
if (isset($input['forcePasswordChange']) && ($input['forcePasswordChange'] == 'true')) {
$forcePasswordChange = true;
}
$sendMail = false;
if (isset($input['sendMail']) && ($input['sendMail'] == 'true')) {
$sendMail = true;
}
$return['forcePasswordChange'] = $forcePasswordChange;
2011-05-15 18:26:28 +00:00
if ($return['errorsOccured'] == 'false') {
// set new password
2019-01-02 20:10:32 +00:00
foreach ($this->module as $module) {
2011-05-15 18:26:28 +00:00
if ($module instanceof passwordService) {
$messages = $module->passwordChangeRequested($password1, $modules, $forcePasswordChange);
2011-05-15 18:26:28 +00:00
for ($m = 0; $m < sizeof($messages); $m++) {
if ($messages[$m][0] == 'ERROR') {
$return['errorsOccured'] = 'true';
}
if (sizeof($messages[$m]) == 2) {
$return['messages'] .= StatusMessage($messages[$m][0], $messages[$m][1], '', array(), true);
}
elseif (sizeof($messages[$m]) == 3) {
$return['messages'] .= StatusMessage($messages[$m][0], $messages[$m][1], $messages[$m][2], array(), true);
}
elseif (sizeof($messages[$m]) == 4) {
2011-05-20 17:57:36 +00:00
$return['messages'] .= StatusMessage($messages[$m][0], $messages[$m][1], $messages[$m][2], $messages[$m][3], true);
2011-05-15 18:26:28 +00:00
}
}
}
2009-10-09 18:21:12 +00:00
}
}
if (isLAMProVersion() && $sendMail) {
$this->sendPasswordViaMail = $password1;
2014-02-10 19:16:37 +00:00
if (($_SESSION['config']->getLamProMailAllowAlternateAddress() != 'false') && !empty($input['sendMailAlternateAddress'])) {
if (!get_preg($input['sendMailAlternateAddress'], 'email')) {
$return['messages'] .= StatusMessage('ERROR', _('Alternate recipient'), _('Please enter a valid email address!'), array(), true);
$return['errorsOccured'] = 'true';
}
$this->sendPasswordViaMailAlternateAddress = $input['sendMailAlternateAddress'];
}
}
2011-05-15 18:26:28 +00:00
if ($return['errorsOccured'] == 'false') {
$return['messages'] .= StatusMessage('INFO', _('The new password will be stored in the directory after you save this account.'), '', array(), true);
}
2015-06-24 17:40:20 +00:00
return $return;
}
2015-06-24 17:40:20 +00:00
2013-12-29 18:10:26 +00:00
/**
* Returns if any module manages the mail attribute.
2015-06-24 17:40:20 +00:00
*
2013-12-29 18:10:26 +00:00
* @return boolean mail is managed
*/
private function anyModuleManagesMail() {
foreach ($this->module as $mod) {
2017-04-22 14:14:15 +00:00
if (in_array('mail', $mod->getManagedAttributes($this->get_type()->getId()))) {
2013-12-29 18:10:26 +00:00
return true;
}
}
return false;
}
2015-06-24 17:40:20 +00:00
2007-12-30 16:08:54 +00:00
/**
* Prints common controls like the save button and the ou selection.
2015-06-24 17:40:20 +00:00
*
* @param int $tabindex tabindex for GUI elements
2007-12-30 16:08:54 +00:00
*/
private function printCommonControls(&$tabindex) {
2019-02-23 17:42:21 +00:00
$row = new htmlResponsiveRow();
$row->setCSSClasses(array('maxrow'));
$leftButtonGroup = new htmlGroup();
$leftButtonGroup->alignment = htmlElement::ALIGN_LEFT;
2007-12-30 16:08:54 +00:00
// save button
$saveButton = new htmlButton('accountContainerSaveAccount', _('Save'));
$saveButton->setIconClass('saveButton');
2019-09-17 10:02:21 +00:00
$saveButton->setCSSClasses(array('fullwidth-mobile-only'));
$leftButtonGroup->addElement($saveButton);
$leftButtonGroup->addElement(new htmlSpacer('1px', null));
2007-12-30 16:08:54 +00:00
// reset button
2013-02-17 13:30:40 +00:00
if (!$this->isNewAccount) {
$resetButton = new htmlButton('accountContainerReset', _('Reset changes'));
$resetButton->setIconClass('undoButton');
2019-09-17 10:02:21 +00:00
$resetButton->setCSSClasses(array('fullwidth-mobile-only'));
2013-02-17 13:30:40 +00:00
$leftButtonGroup->addElement($resetButton);
}
// set password button
if ($this->showSetPasswordButton()) {
$leftButtonGroup->addElement(new htmlSpacer('15px', null));
$passwordButton = new htmlButton('accountContainerPassword', _('Set password'));
$passwordButton->setIconClass('passwordButton');
2019-09-17 10:02:21 +00:00
$passwordButton->setCSSClasses(array('fullwidth-mobile-only'));
$passwordButton->setOnClick('passwordShowChangeDialog(\'' . _('Set password') . '\', \'' . _('Ok') . '\', \''
2019-05-23 20:09:05 +00:00
. _('Cancel') . '\', \'' . _('Set random password') . '\', \'../misc/ajax.php?function=passwordChange&editKey=' . htmlspecialchars($this->base) . '\',\''
. getSecurityTokenName() . '\',\'' . getSecurityTokenValue() . '\');');
$leftButtonGroup->addElement($passwordButton);
}
2019-11-07 20:05:11 +00:00
// delete button
2019-08-31 09:15:49 +00:00
if (!$this->isNewAccount) {
$leftButtonGroup->addElement(new htmlSpacer('15px', null));
$deleteButton = new htmlButton('accountContainerDelete', _('Delete'));
$deleteButton->setIconClass('deleteButton');
2019-09-17 10:02:21 +00:00
$deleteButton->setCSSClasses(array('fullwidth-mobile-only'));
2019-08-31 09:15:49 +00:00
$leftButtonGroup->addElement($deleteButton);
}
2019-11-07 20:05:11 +00:00
$row->add($leftButtonGroup, 12, 9);
2015-06-24 17:40:20 +00:00
$rightGroup = new htmlGroup();
2007-12-30 16:08:54 +00:00
// profile selection
2017-01-06 12:56:17 +00:00
$profilelist = \LAM\PROFILES\getAccountProfiles($this->type->getId());
2007-12-30 16:08:54 +00:00
if (sizeof($profilelist) > 0) {
2019-02-23 17:42:21 +00:00
$profilesSelect = new htmlSelect('accountContainerSelectLoadProfile', $profilelist, array($this->lastLoadedProfile));
$profilesSelect->setCSSClasses(array('auto-width'));
$rightGroup->addElement($profilesSelect);
$profileButton = new htmlButton('accountContainerLoadProfile', _('Load profile'));
$profileButton->setIconClass('loadProfileButton');
if (!$this->isNewAccount) {
$profileButton->setType('submit');
$profileButton->setOnClick('confirmOrStopProcessing(\'' . _('This may overwrite existing values with profile data. Continue?') . '\', event);');
}
$rightGroup->addElement($profileButton);
$rightGroup->addElement(new htmlSpacer('1px', null));
$rightGroup->addElement(new htmlHelpLink('401'));
}
2019-11-07 20:05:11 +00:00
$row->add($rightGroup, 12, 3, 3, 'text-right');
2015-06-24 17:40:20 +00:00
2019-02-23 17:42:21 +00:00
parseHtml(null, $row, array(), false, $tabindex, $this->type->getScope());
2007-12-30 16:08:54 +00:00
}
2015-06-24 17:40:20 +00:00
/**
* Returns if the page should show a button to set the password.
*
* @return boolean show or hide button
*/
private function showSetPasswordButton() {
2019-01-02 20:10:32 +00:00
foreach ($this->module as $module) {
if (($module instanceof passwordService) && $module->managesPasswordAttributes()) {
return true;
}
}
return false;
}
2015-06-24 17:40:20 +00:00
2007-12-26 18:49:04 +00:00
/**
* Prints the header of the account pages.
*/
private function printPageHeader() {
2015-05-15 19:16:46 +00:00
if (!empty($_POST)) {
validateSecurityToken();
}
2019-02-23 17:42:21 +00:00
include '../../lib/adminHeader.inc';
2013-05-01 16:55:59 +00:00
echo '<script type="text/javascript">
jQuery(document).ready(function() {
2019-09-22 11:19:26 +00:00
jQuery("#inputForm").validationEngine({promptPosition: "topLeft", addFailureCssClassToField: "lam-input-error", autoHidePrompt: true, autoHideDelay: 5000});
2013-05-01 16:55:59 +00:00
});
</script>';
2019-05-23 20:09:05 +00:00
echo "<form id=\"inputForm\" enctype=\"multipart/form-data\" action=\"edit.php?editKey=" . htmlspecialchars($this->base) . "\" method=\"post\" onSubmit=\"saveScrollPosition('inputForm')\" autocomplete=\"off\">\n";
2015-06-24 17:40:20 +00:00
echo '<input type="hidden" name="' . getSecurityTokenName() . '" value="' . getSecurityTokenValue() . '">';
2007-12-26 18:49:04 +00:00
}
2015-06-24 17:40:20 +00:00
2007-12-26 18:49:04 +00:00
/**
* Prints the footer of the account pages.
*/
private function printPageFooter() {
echo "</form>\n";
2019-02-23 17:42:21 +00:00
include '../../lib/adminFooter.inc';
2007-12-26 18:49:04 +00:00
}
2015-06-24 17:40:20 +00:00
2007-12-26 18:49:04 +00:00
/**
* Prints the HTML code to notify the user about the successful saving.
*
2012-01-04 19:08:19 +00:00
* @param array $messages array which contains status messages. Each entry is an array containing the status message parameters.
2007-12-26 18:49:04 +00:00
*/
2012-01-04 19:08:19 +00:00
private function printSuccessPage($messages) {
2007-12-26 18:49:04 +00:00
$this->printPageHeader();
// Show success message
if ($this->dn_orig == '') {
$text = _("Account was created successfully.");
}
else {
$text = _("Account was modified successfully.");
}
2016-12-24 14:39:02 +00:00
echo "<div class=\"" . $this->type->getScope() . "-bright smallPaddingContent\">";
2015-06-24 17:40:20 +00:00
$container = new htmlTable();
2012-01-04 19:08:19 +00:00
// show messages
for ($i = 0; $i < sizeof($messages); $i++) {
if (sizeof($messages[$i]) == 2) {
$message = new htmlStatusMessage($messages[$i][0], $messages[$i][1]);
$message->colspan = 10;
$container->addElement($message, true);
}
else {
$message = new htmlStatusMessage($messages[$i][0], $messages[$i][1], $messages[$i][2]);
$message->colspan = 10;
$container->addElement($message, true);
}
}
$message = new htmlStatusMessage('INFO', _('LDAP operation successful.'), $text);
2011-05-03 16:15:38 +00:00
$message->colspan = 10;
$container->addElement($message, true);
$container->addElement(new htmlSpacer(null, '20px'), true);
2015-06-24 17:40:20 +00:00
2016-12-24 14:39:02 +00:00
$type = $this->type->getBaseType();
2013-02-10 18:43:27 +00:00
$buttonGroup = new htmlGroup();
2016-12-24 14:39:02 +00:00
if (checkIfNewEntriesAreAllowed($this->type->getId())) {
$createButton = new htmlButton('accountContainerCreateAgain', $type->LABEL_CREATE_ANOTHER_ACCOUNT);
$createButton->setIconClass('createButton');
$buttonGroup->addElement($createButton);
$buttonGroup->addElement(new htmlSpacer('10px', null));
}
2011-05-03 16:15:38 +00:00
$pdfButton = new htmlButton('accountContainerCreatePDF', _('Create PDF file'));
$pdfButton->setIconClass('pdfButton');
2013-02-10 18:43:27 +00:00
$buttonGroup->addElement($pdfButton);
$buttonGroup->addElement(new htmlSpacer('10px', null));
2011-05-03 16:15:38 +00:00
$backToListButton = new htmlButton('accountContainerBackToList', $type->LABEL_BACK_TO_ACCOUNT_LIST);
$backToListButton->setIconClass('backButton');
2013-02-10 18:43:27 +00:00
$buttonGroup->addElement($backToListButton);
$buttonGroup->addElement(new htmlSpacer('10px', null));
2011-05-03 16:15:38 +00:00
$backToEditButton = new htmlButton('accountContainerBackToEdit', _('Edit again'));
$backToEditButton->setIconClass('editButton');
2013-02-10 18:43:27 +00:00
$buttonGroup->addElement($backToEditButton);
$container->addElement($buttonGroup, true);
2015-06-24 17:40:20 +00:00
$tabindex = 1;
2016-12-24 14:39:02 +00:00
parseHtml(null, $container, array(), false, $tabindex, $this->type->getScope());
echo "</div>\n";
2007-12-26 18:49:04 +00:00
$this->printPageFooter();
}
2015-06-24 17:40:20 +00:00
2007-12-26 18:49:04 +00:00
/**
* Checks if the user requested to load a profile.
2015-06-24 17:40:20 +00:00
*
* @return boolean true, if profile was loaded
2007-12-26 18:49:04 +00:00
*/
private function loadProfileIfRequested() {
if (isset($_POST['accountContainerLoadProfile']) && isset($_POST['accountContainerSelectLoadProfile'])) {
2017-01-06 12:56:17 +00:00
$profile = \LAM\PROFILES\loadAccountProfile($_POST['accountContainerSelectLoadProfile'], $this->type->getId());
2007-12-26 18:49:04 +00:00
$this->lastLoadedProfile = $_POST['accountContainerSelectLoadProfile'];
// pass profile to each module
$modules = array_keys($this->module);
2019-01-02 20:10:32 +00:00
foreach ($modules as $module) {
$this->module[$module]->load_profile($profile);
}
if (isset($profile['ldap_rdn'][0])
&& in_array($profile['ldap_rdn'][0], getRDNAttributes($this->type->getId()))) {
$this->rdn = $profile['ldap_rdn'][0];
2007-12-26 18:49:04 +00:00
}
2011-05-14 13:51:08 +00:00
if (isset($profile['ldap_suffix'][0]) && ($profile['ldap_suffix'][0] != '-')) {
$this->dnSuffix = $profile['ldap_suffix'][0];
2007-12-26 18:49:04 +00:00
}
return true;
2007-12-26 18:49:04 +00:00
}
return false;
2007-12-26 18:49:04 +00:00
}
2015-06-24 17:40:20 +00:00
2007-12-26 18:49:04 +00:00
/**
* Prints the HTML code of the module tabs.
*/
private function printModuleTabs() {
// $x is used to count up tabindex
2015-06-24 17:40:20 +00:00
$x=1;
2019-08-15 12:13:10 +00:00
echo '<ul class="ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all">';
2010-06-23 17:35:43 +00:00
// Loop for each module
2015-12-20 19:07:04 +00:00
for ($i = 0; $i < count($this->order); $i++) {
2007-10-03 18:25:55 +00:00
$buttonStatus = $this->module[$this->order[$i]]->getButtonStatus();
2015-12-20 19:07:04 +00:00
$alias = $this->module[$this->order[$i]]->get_alias();
2007-10-03 18:25:55 +00:00
// skip hidden buttons
2019-01-02 20:10:32 +00:00
if ($buttonStatus == 'hidden') {
continue;
}
2007-11-19 18:42:03 +00:00
$buttonImage = $this->module[$this->order[$i]]->getIcon();
2010-06-23 17:35:43 +00:00
$activatedClass = '';
if ($this->order[$this->current_page] == $this->order[$i]) {
2016-12-24 14:39:02 +00:00
$activatedClass = ' ui-tabs-selected ui-state-active ' . $this->type->getScope() . '-bright';
2010-06-23 17:35:43 +00:00
}
// print button
echo '<li class="ui-state-default ui-corner-left' . $activatedClass . '">';
2019-08-15 12:13:10 +00:00
echo "<button class=\"lam-account-type\" name=\"form_main_".$this->order[$i]."\"";
echo " tabindex=$x";
2019-01-02 20:10:32 +00:00
if ($buttonStatus == 'disabled') {
echo " disabled";
}
2011-01-06 17:38:16 +00:00
echo ' onmouseover="jQuery(this).addClass(\'tabs-hover\');" onmouseout="jQuery(this).removeClass(\'tabs-hover\');">';
2007-11-19 18:42:03 +00:00
if ($buttonImage != null) {
if (!(strpos($buttonImage, 'http') === 0) && !(strpos($buttonImage, '/') === 0)) {
$buttonImage = '../../graphics/' . $buttonImage;
}
echo "<img height=32 width=32 class=\"align-middle\" style=\"padding: 3px;\" alt=\"\" src=\"$buttonImage\">&nbsp;";
2007-11-19 18:42:03 +00:00
}
2019-08-15 12:13:10 +00:00
echo '<span class="hide-on-mobile">';
2015-12-20 19:07:04 +00:00
echo $alias;
2019-08-15 12:13:10 +00:00
echo '<span>';
echo "&nbsp;</button>\n";
2010-06-23 17:35:43 +00:00
echo "</li>\n";
$x++;
2005-08-26 08:53:16 +00:00
}
2010-09-04 13:52:03 +00:00
echo '</ul>';
2006-05-13 08:55:31 +00:00
}
2015-06-24 17:40:20 +00:00
/**
* This function checks which LDAP attributes have changed while the account was edited.
2006-08-14 17:29:45 +00:00
*
* @param array $attributes list of current LDAP attributes
* @param array $orig list of old attributes when account was loaded
* @return array an array which can be passed to $this->saveAccount()
2004-02-07 18:34:26 +00:00
*/
function save_module_attributes($attributes, $orig) {
2011-02-26 13:14:10 +00:00
$return = array();
2006-05-01 16:13:10 +00:00
$toadd = array();
$tomodify = array();
$torem = array();
$notchanged = array();
// get list of all attributes
2004-02-07 18:34:26 +00:00
$attr_names = array_keys($attributes);
$orig_names = array_keys($orig);
// find deleted attributes (in $orig but no longer in $attributes)
foreach ($orig_names as $i => $value) {
if (!isset($attributes[$value])) {
$torem[$value] = $orig[$value];
}
}
2006-05-07 08:49:47 +00:00
// find changed attributes
foreach ($attr_names as $i => $name) {
2006-05-07 08:49:47 +00:00
// find deleted attributes
if (isset($orig[$name]) && is_array($orig[$name])) {
2020-03-19 18:55:58 +00:00
foreach ($orig[$name] as $value) {
if (is_array($attributes[$name])) {
2019-01-02 20:10:32 +00:00
if (!in_array($value, $attributes[$name], true)
&& ($value !== null)
&& ($value !== '')) {
$torem[$name][] = $value;
}
2004-02-07 18:34:26 +00:00
}
2017-09-24 07:48:42 +00:00
elseif (($value !== null) && ($value !== '')) {
$torem[$name][] = $value;
}
2004-02-07 18:34:26 +00:00
}
2006-05-07 08:49:47 +00:00
}
// find new attributes
if (isset($attributes[$name]) && is_array($attributes[$name])) {
2020-03-19 18:55:58 +00:00
foreach ($attributes[$name] as $value) {
2010-05-19 19:22:29 +00:00
if (isset($orig[$name]) && is_array($orig[$name])) {
2019-01-02 20:10:32 +00:00
if (!in_array($value, $orig[$name], true)
&& ($value !== null)
&& ($value !== ''))
$toadd[$name][] = $value;
}
2017-09-24 07:48:42 +00:00
elseif (($value !== null) && ($value !== '')) {
$toadd[$name][] = $value;
}
2004-02-07 18:34:26 +00:00
}
2006-05-07 08:49:47 +00:00
}
// find unchanged attributes
2010-05-19 19:22:29 +00:00
if (isset($orig[$name]) && is_array($orig[$name]) && is_array($attributes[$name])) {
2020-03-19 18:55:58 +00:00
foreach ($attributes[$name] as $value) {
2017-09-24 07:48:42 +00:00
if (($value !== null) && ($value !== '') && in_array($value, $orig[$name], true)) {
$notchanged[$name][] = $value;
}
2004-02-07 18:34:26 +00:00
}
}
2006-05-07 08:49:47 +00:00
}
// create modify with add and remove
2006-05-07 08:49:47 +00:00
$attributes2 = array_keys($toadd);
for ($i=0; $i<count($attributes2); $i++) {
2017-09-24 07:48:42 +00:00
if (isset($torem[$attributes2[$i]]) && (count($toadd[$attributes2[$i]]) > 0) && (count($torem[$attributes2[$i]]) > 0)) {
// found attribute which should be modified
$tomodify[$attributes2[$i]] = $toadd[$attributes2[$i]];
// merge unchanged values
if (isset($notchanged[$attributes2[$i]])) {
$tomodify[$attributes2[$i]] = array_merge($tomodify[$attributes2[$i]], $notchanged[$attributes2[$i]]);
unset($notchanged[$attributes2[$i]]);
2004-02-07 18:34:26 +00:00
}
2017-09-24 07:48:42 +00:00
// remove old add and remove commands
unset($toadd[$attributes2[$i]]);
unset($torem[$attributes2[$i]]);
2004-02-07 18:34:26 +00:00
}
}
2017-09-24 07:48:42 +00:00
if (count($toadd) > 0) {
$return[$this->dn_orig]['add'] = $toadd;
}
if (count($torem) > 0) {
$return[$this->dn_orig]['remove'] = $torem;
}
if (count($tomodify) > 0) {
$return[$this->dn_orig]['modify'] = $tomodify;
}
if (count($notchanged) > 0) {
$return[$this->dn_orig]['notchanged'] = $notchanged;
}
return $return;
}
2004-02-07 18:34:26 +00:00
/**
* Loads an LDAP account with the given DN.
*
* @param string $dn the DN of the account
* @param array $infoAttributes list of additional informational attributes that are added to the LDAP attributes
2015-06-24 17:40:20 +00:00
* E.g. this is used to inject the clear text password in the file upload. Informational attribute names must start with "INFO.".
2006-09-16 13:26:18 +00:00
* @return array error messages
2004-02-07 18:34:26 +00:00
*/
function load_account($dn, $infoAttributes = array()) {
2010-01-25 16:38:36 +00:00
logNewMessage(LOG_DEBUG, "Edit account " . $dn);
2006-09-16 13:26:18 +00:00
$this->module = array();
2016-12-24 14:39:02 +00:00
$modules = $_SESSION['config']->get_AccountModules($this->type->getId());
2018-04-05 16:41:44 +00:00
$filter = 'objectClass=*';
$searchAttrs = array('*', '+');
foreach ($modules as $module) {
2016-12-24 14:39:02 +00:00
$modTmp = new $module($this->type->getScope());
2017-12-22 09:43:02 +00:00
$searchAttrs = array_merge($searchAttrs, $modTmp->getManagedHiddenAttributes($this->type->getId()));
}
2018-04-05 16:41:44 +00:00
$result = @ldap_read($_SESSION['ldap']->server(), escapeDN($dn), $filter, $searchAttrs, 0, 0, 0, LDAP_DEREF_NEVER);
2006-09-16 13:26:18 +00:00
if (!$result) {
2013-10-16 17:37:17 +00:00
return array(array("ERROR", _("Unable to load LDAP entry:") . " " . htmlspecialchars($dn), getDefaultLDAPErrorString($_SESSION['ldap']->server())));
2006-09-16 13:26:18 +00:00
}
$entry = @ldap_first_entry($_SESSION['ldap']->server(), $result);
if (!$entry) {
2013-10-16 17:37:17 +00:00
return array(array("ERROR", _("Unable to load LDAP entry:") . " " . htmlspecialchars($dn), getDefaultLDAPErrorString($_SESSION['ldap']->server())));
2006-09-16 13:26:18 +00:00
}
$this->dnSuffix = extractDNSuffix($dn);
2004-02-07 18:34:26 +00:00
$this->dn_orig = $dn;
2005-05-02 17:41:09 +00:00
// extract RDN
$this->rdn = extractRDNAttribute($dn);
$attr = ldap_get_attributes($_SESSION['ldap']->server(), $entry);
2011-05-21 10:58:22 +00:00
$attr = array($attr);
cleanLDAPResult($attr);
$attr = $attr[0];
// fix spelling errors
$attr = $this->fixLDAPAttributes($attr, $modules);
2005-12-05 14:27:47 +00:00
// get binary attributes
$binaryAttr = array('jpegPhoto');
for ($i = 0; $i < sizeof($binaryAttr); $i++) {
if (isset($attr[$binaryAttr[$i]][0])) {
$binData = ldap_get_values_len($_SESSION['ldap']->server(), $entry, $binaryAttr[$i]);
unset($binData['count']);
$attr[$binaryAttr[$i]] = $binData;
}
}
// add informational attributes
$attr = array_merge($attr, $infoAttributes);
2005-05-02 17:41:09 +00:00
// save original attributes
$this->attributes_orig = $attr;
2006-08-14 17:29:45 +00:00
foreach ($modules as $module) {
if (!isset($this->module[$module])) {
2016-12-24 14:39:02 +00:00
$this->module[$module] = new $module($this->type->getScope());
$this->module[$module]->init($this->base);
}
$this->module[$module]->load_attributes($attr);
2012-03-18 18:24:00 +00:00
}
2004-02-07 18:34:26 +00:00
2005-08-23 12:16:58 +00:00
// sort module buttons
$this->sortModules();
// get titles
2016-12-24 14:39:02 +00:00
$typeObject = $this->type->getBaseType();
$this->titleBarTitle = $typeObject->getTitleBarTitle($this);
$this->titleBarSubtitle = $typeObject->getTitleBarSubtitle($this);
2006-09-16 13:26:18 +00:00
return array();
}
2006-08-14 17:29:45 +00:00
/**
* Fixes spelling errors in the attribute names.
*
* @param array $attributes LDAP attributes
* @param array $modules list of active modules
* @return array fixed attributes
*/
function fixLDAPAttributes($attributes, $modules) {
2019-01-02 20:10:32 +00:00
if (!is_array($attributes)) {
return $attributes;
}
$keys = array_keys($attributes);
2006-05-01 16:13:10 +00:00
// get correct object class names, aliases and attributes
$objectClasses = array();
2006-05-01 16:13:10 +00:00
$aliases = array();
2006-07-23 15:03:35 +00:00
$ldapAttributesTemp = array();
foreach ($modules as $module) {
2016-12-24 14:39:02 +00:00
$moduleObj = moduleCache::getModule($module, $this->type->getScope());
2017-04-22 14:14:15 +00:00
$objectClasses = array_merge($objectClasses, $moduleObj->getManagedObjectClasses($this->type->getId()));
$aliases = array_merge($aliases, $moduleObj->getLDAPAliases($this->type->getId()));
$ldapAttributesTemp = array_merge($ldapAttributesTemp, $moduleObj->getManagedAttributes($this->type->getId()));
2004-02-07 18:34:26 +00:00
}
2006-07-23 15:03:35 +00:00
// build lower case attribute names
$ldapAttributes = array();
for ($i = 0; $i < sizeof($ldapAttributesTemp); $i++) {
$ldapAttributes[strtolower($ldapAttributesTemp[$i])] = $ldapAttributesTemp[$i];
unset($ldapAttributes[$i]);
}
$ldapAttributesKeys = array_keys($ldapAttributes);
2006-05-01 16:13:10 +00:00
// convert alias names to lower case (for easier comparison)
$aliasKeys = array_keys($aliases);
for ($i = 0; $i < sizeof($aliasKeys); $i++) {
if ($aliasKeys[$i] != strtolower($aliasKeys[$i])) {
$aliases[strtolower($aliasKeys[$i])] = $aliases[$aliasKeys[$i]];
unset($aliases[$aliasKeys[$i]]);
$aliasKeys[$i] = strtolower($aliasKeys[$i]);
}
}
// fix object classes and attributes
for ($i = 0; $i < sizeof($keys); $i++) {
2006-05-01 16:13:10 +00:00
// check object classes
if (strtolower($keys[$i]) == 'objectclass') {
// fix object class attribute
if ($keys[$i] != 'objectClass') {
$temp = $attributes[$keys[$i]];
unset($attributes[$keys[$i]]);
$attributes['objectClass'] = $temp;
}
// fix object classes
for ($attrClass = 0; $attrClass < sizeof($attributes['objectClass']); $attrClass++) {
for ($modClass = 0; $modClass < sizeof($objectClasses); $modClass++) {
if (strtolower($attributes['objectClass'][$attrClass]) == strtolower($objectClasses[$modClass])) {
if ($attributes['objectClass'][$attrClass] != $objectClasses[$modClass]) {
unset($attributes['objectClass'][$attrClass]);
$attributes['objectClass'][] = $objectClasses[$modClass];
}
break;
}
}
}
2006-05-01 16:13:10 +00:00
}
else {
// fix aliases
if (in_array(strtolower($keys[$i]), $aliasKeys)) {
$attributes[$aliases[strtolower($keys[$i])]] = $attributes[$keys[$i]];
unset($attributes[$keys[$i]]);
}
2006-07-23 15:03:35 +00:00
// fix attribute names
elseif (in_array(strtolower($keys[$i]), $ldapAttributesKeys)) {
if ($keys[$i] != $ldapAttributes[strtolower($keys[$i])]) {
$attributes[$ldapAttributes[strtolower($keys[$i])]] = $attributes[$keys[$i]];
unset($attributes[$keys[$i]]);
}
}
}
}
return $attributes;
}
2004-02-07 18:34:26 +00:00
/**
* This function will prepare the object for a new account.
2004-02-07 18:34:26 +00:00
*/
public function new_account() {
2016-12-24 14:39:02 +00:00
logNewMessage(LOG_DEBUG, "New account with type " . $this->type->getId());
$this->isNewAccount = true;
2007-12-04 15:58:05 +00:00
$this->lastLoadedProfile = 'default';
$this->initModules();
2005-08-23 12:16:58 +00:00
// sort module buttons
$this->sortModules();
$profileName = 'default';
$profileCookieKey = 'defaultProfile_' . $this->get_type()->getId();
if (!empty($_COOKIE[$profileCookieKey])) {
$cookieProfileName = $_COOKIE[$profileCookieKey];
2017-10-21 19:37:07 +00:00
if (\LAM\PROFILES\profileExists($cookieProfileName, $this->get_type()->getId())) {
$profileName = $cookieProfileName;
$this->lastLoadedProfile = $cookieProfileName;
}
}
$profile = \LAM\PROFILES\loadAccountProfile($profileName, $this->type->getId());
2005-04-16 10:58:18 +00:00
// pass profile to each module
$modules = array_keys($this->module);
foreach ($modules as $module) $this->module[$module]->load_profile($profile);
2020-03-19 19:42:36 +00:00
if (isset($profile['ldap_rdn'][0]) && in_array($profile['ldap_rdn'][0], getRDNAttributes($this->type->getId()))) {
$this->rdn = $profile['ldap_rdn'][0];
}
2011-05-14 13:51:08 +00:00
if (isset($profile['ldap_suffix'][0]) && ($profile['ldap_suffix'][0] != '-')) {
$this->dnSuffix = $profile['ldap_suffix'][0];
}
// get titles
2016-12-24 14:39:02 +00:00
$typeObject = $this->type->getBaseType();
$this->titleBarTitle = $typeObject->getTitleBarTitle($this);
$this->titleBarSubtitle = $typeObject->getTitleBarSubtitle($this);
2004-02-07 18:34:26 +00:00
return 0;
}
2004-02-07 18:34:26 +00:00
/**
* Creates the account modules and initializes them.
*/
public function initModules() {
$modules = $_SESSION['config']->get_AccountModules($this->type->getId());
foreach ($modules as $module) {
$this->module[$module] = new $module($this->type->getScope());
$this->module[$module]->init($this->base);
}
}
2005-05-02 17:41:09 +00:00
/**
* This function will save an account to the LDAP database.
*
2012-01-04 19:08:19 +00:00
* @return array list of status messages
2004-02-07 18:34:26 +00:00
*/
2019-08-31 09:07:06 +00:00
private function save_account() {
2016-12-24 14:39:02 +00:00
if (!checkIfWriteAccessIsAllowed($this->type->getId())) {
2007-12-30 16:08:54 +00:00
die();
}
$this->finalDN = $this->dn_orig;
2006-08-27 14:57:22 +00:00
$errors = array();
2016-12-29 19:12:15 +00:00
$module = array_keys($this->module);
2004-02-07 18:34:26 +00:00
$attributes = array();
// load attributes
foreach ($module as $singlemodule) {
// load changes
$temp = $this->module[$singlemodule]->save_attributes();
2019-01-02 20:10:32 +00:00
if (!is_array($temp)) {
$temp = array();
}
2004-02-07 18:34:26 +00:00
// merge changes
$DNs = array_keys($temp);
2019-01-02 20:10:32 +00:00
if (is_array($temp)) {
$attributes = array_merge_recursive($temp, $attributes);
}
2016-12-29 19:12:15 +00:00
for ($i = 0; $i < count($DNs); $i++) {
2004-02-07 18:34:26 +00:00
$ops = array_keys($temp[$DNs[$i]]);
for ($j=0; $j<count($ops); $j++) {
$attrs = array_keys($temp[$DNs[$i]][$ops[$j]]);
for ($k=0; $k<count($attrs); $k++) {
$attributes[$DNs[$i]][$ops[$j]][$attrs[$k]] = array_values(array_unique($attributes[$DNs[$i]][$ops[$j]][$attrs[$k]]));
2004-02-07 18:34:26 +00:00
}
}
}
}
// build DN for new accounts and change it for existing ones if needed
if (isset($attributes[$this->dn_orig]['modify'][$this->rdn][0])) {
2018-05-20 06:22:51 +00:00
$this->finalDN = $this->rdn . '=' . escapeRDN($attributes[$this->dn_orig]['modify'][$this->rdn][0]) . ',' . $this->dnSuffix;
if ($this->dn_orig != $this->finalDN) {
$attributes[$this->finalDN] = $attributes[$this->dn_orig];
unset($attributes[$this->dn_orig]);
}
}
elseif (isset($attributes[$this->dn_orig]['add'][$this->rdn][0])) {
2018-05-20 06:22:51 +00:00
$this->finalDN = $this->rdn . '=' . escapeRDN($attributes[$this->dn_orig]['add'][$this->rdn][0]) . ',' . $this->dnSuffix;
if ($this->dn_orig != $this->finalDN) {
$attributes[$this->finalDN] = $attributes[$this->dn_orig];
unset($attributes[$this->dn_orig]);
2004-02-07 18:34:26 +00:00
}
}
2014-04-21 19:21:47 +00:00
elseif (isset($attributes[$this->dn_orig]['remove'][$this->rdn][0]) && isset($attributes[$this->dn_orig]['notchanged'][$this->rdn][0])) {
2018-05-20 06:22:51 +00:00
$this->finalDN = $this->rdn . '=' . escapeRDN($attributes[$this->dn_orig]['notchanged'][$this->rdn][0]) . ',' . $this->dnSuffix;
2014-04-21 19:21:47 +00:00
if ($this->dn_orig != $this->finalDN) {
$attributes[$this->finalDN] = $attributes[$this->dn_orig];
unset($attributes[$this->dn_orig]);
}
}
2011-12-11 13:07:48 +00:00
elseif (!$this->isNewAccount && (($this->dnSuffix != extractDNSuffix($this->dn_orig)) || ($this->rdn != extractRDNAttribute($this->dn_orig)))) {
2018-05-20 06:22:51 +00:00
$this->finalDN = $this->rdn . '=' . escapeRDN($attributes[$this->dn_orig]['notchanged'][$this->rdn][0]) . ',' . $this->dnSuffix;
$attributes[$this->finalDN] = $attributes[$this->dn_orig];
unset($attributes[$this->dn_orig]);
}
2012-09-27 16:14:19 +00:00
// remove pwdAccountLockedTime attribute change if also userPassword is changed (PPolicy will remove this attribute itself)
2012-09-27 16:16:46 +00:00
if (isset($attributes[$this->finalDN]['modify']['userPassword']) || isset($attributes[$this->finalDN]['remove']['userPassword'])) {
2012-09-27 16:14:19 +00:00
if (isset($attributes[$this->finalDN]['modify']['pwdAccountLockedTime'])) {
unset($attributes[$this->finalDN]['modify']['pwdAccountLockedTime']);
}
if (isset($attributes[$this->finalDN]['remove']['pwdAccountLockedTime'])) {
unset($attributes[$this->finalDN]['remove']['pwdAccountLockedTime']);
}
}
// pre modify actions
2011-02-26 13:14:10 +00:00
$prePostModifyAttributes = array();
if (isset($attributes[$this->finalDN]) && is_array($attributes[$this->finalDN])) {
2011-01-12 21:07:28 +00:00
if (isset($attributes[$this->finalDN]['notchanged'])) {
2011-02-26 13:14:10 +00:00
$prePostModifyAttributes = array_merge($prePostModifyAttributes, $attributes[$this->finalDN]['notchanged']);
2011-01-12 21:07:28 +00:00
}
if (isset($attributes[$this->finalDN]['modify'])) {
2012-10-06 16:37:36 +00:00
foreach ($attributes[$this->finalDN]['modify'] as $key => $value) {
$prePostModifyAttributes[$key] = &$attributes[$this->finalDN]['modify'][$key];
}
2011-02-26 13:14:10 +00:00
foreach ($attributes[$this->finalDN]['modify'] as $key => $value) {
$prePostModifyAttributes['MOD.' . $key] = $value;
}
}
if (isset($attributes[$this->finalDN]['add'])) {
2012-10-06 16:37:36 +00:00
foreach ($attributes[$this->finalDN]['add'] as $key => $value) {
$prePostModifyAttributes[$key] = &$attributes[$this->finalDN]['add'][$key];
}
2011-02-26 13:14:10 +00:00
foreach ($attributes[$this->finalDN]['add'] as $key => $value) {
$prePostModifyAttributes['NEW.' . $key] = $value;
}
}
if (isset($attributes[$this->finalDN]['remove'])) {
foreach ($attributes[$this->finalDN]['remove'] as $key => $value) {
$prePostModifyAttributes['DEL.' . $key] = $value;
}
}
if (isset($attributes[$this->finalDN]['info'])) {
foreach ($attributes[$this->finalDN]['info'] as $key => $value) {
$prePostModifyAttributes['INFO.' . $key] = $value;
}
}
}
2012-07-25 19:17:37 +00:00
if (!$this->isNewAccount) {
foreach ($this->attributes_orig as $key => $value) {
$prePostModifyAttributes['ORIG.' . $key] = $value;
}
$prePostModifyAttributes['ORIG.dn'][0] = $this->dn_orig;
}
2011-02-26 13:14:10 +00:00
$prePostModifyAttributes['dn'][0] = $this->finalDN;
2012-06-02 17:45:37 +00:00
if (!$this->isNewAccount && ($this->finalDN != $this->dn_orig)) {
2012-07-25 19:17:37 +00:00
$prePostModifyAttributes['MOD.dn'][0] = $this->finalDN;
2012-06-02 17:45:37 +00:00
}
2011-02-26 13:14:10 +00:00
logNewMessage(LOG_DEBUG, 'Edit page pre/postModify attributes: ' . print_r($prePostModifyAttributes, true));
$preModifyOk = true;
foreach ($module as $singlemodule) {
$preModifyMessages = $this->module[$singlemodule]->preModifyActions($this->isNewAccount, $prePostModifyAttributes);
$errors = array_merge($errors, $preModifyMessages);
for ($i = 0; $i < sizeof($preModifyMessages); $i++) {
if ($preModifyMessages[$i][0] == 'ERROR') {
$preModifyOk = false;
break;
}
}
}
if (!$preModifyOk) {
$errors[] = array('ERROR', _('The operation was stopped because of the above errors.'));
return $errors;
}
2004-02-07 18:34:26 +00:00
// Set to true if an real error has happened
$stopprocessing = false;
if (strtolower($this->finalDN) != convertCommaEscaping(strtolower($this->dn_orig))) {
2006-05-07 08:49:47 +00:00
// move existing DN
if ($this->dn_orig != '') {
2013-10-06 14:51:17 +00:00
$removeOldRDN = false;
if (isset($attributes[$this->finalDN]['modify'])) {
$attributes[$this->finalDN]['modify'] = array_change_key_case($attributes[$this->finalDN]['modify'], CASE_LOWER);
}
$rdnAttr = strtolower(extractRDNAttribute($this->finalDN));
if (isset($attributes[$this->finalDN]['modify'][$rdnAttr])
&& (sizeof($attributes[$this->finalDN]['modify'][$rdnAttr]) == 1)
&& ($attributes[$this->finalDN]['modify'][$rdnAttr][0] == extractRDNValue($this->finalDN))) {
// remove old RDN if attribute is single valued
$removeOldRDN = true;
2013-11-24 10:04:19 +00:00
unset($attributes[$this->finalDN]['modify'][extractRDNAttribute($this->finalDN)]);
2013-10-06 14:51:17 +00:00
}
2014-04-21 19:21:47 +00:00
if (isset($attributes[$this->finalDN]['notchanged'][$rdnAttr])
&& !(isset($attributes[$this->finalDN]['add'][$rdnAttr]) || isset($attributes[$this->finalDN]['modify'][$rdnAttr]) || isset($attributes[$this->finalDN]['remove'][$rdnAttr]))) {
2013-12-26 11:22:26 +00:00
// fix for AD which requires to remove RDN even if not changed
$removeOldRDN = true;
}
logNewMessage(LOG_DEBUG, 'Rename ' . $this->dn_orig . ' to ' . $this->finalDN);
2013-10-06 14:51:17 +00:00
$success = ldap_rename($_SESSION['ldap']->server(), $this->dn_orig, $this->getRDN($this->finalDN), $this->getParentDN($this->finalDN), $removeOldRDN);
2006-05-07 08:49:47 +00:00
if ($success) {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_NOTICE, 'Renamed DN ' . $this->dn_orig . " to " . $this->finalDN);
2014-04-21 19:21:47 +00:00
// do not add attribute value as new one if added via rename operation
if (!empty($attributes[$this->finalDN]['add'][$rdnAttr]) && in_array(extractRDNValue($this->finalDN), $attributes[$this->finalDN]['add'][$rdnAttr])) {
$attributes[$this->finalDN]['add'][$rdnAttr] = array_delete(array(extractRDNValue($this->finalDN)), $attributes[$this->finalDN]['add'][$rdnAttr]);
if (empty($attributes[$this->finalDN]['add'][$rdnAttr])) {
unset($attributes[$this->finalDN]['add'][$rdnAttr]);
}
}
2006-05-07 08:49:47 +00:00
}
2007-05-13 13:02:32 +00:00
else {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_ERR, 'Unable to rename DN: ' . $this->dn_orig . ' (' . ldap_error($_SESSION['ldap']->server()) . '). '
2013-10-16 17:37:17 +00:00
. getExtendedLDAPErrorMessage($_SESSION['ldap']->server()));
$errors[] = array('ERROR', sprintf(_('Was unable to rename DN: %s.'), $this->dn_orig), getDefaultLDAPErrorString($_SESSION['ldap']->server()));
2006-05-07 08:49:47 +00:00
$stopprocessing = true;
}
}
// create complete new dn
else {
$attr = array();
2010-05-19 19:22:29 +00:00
if (isset($attributes[$this->finalDN]['add']) && is_array($attributes[$this->finalDN]['add'])) {
$attr = array_merge_recursive($attr, $attributes[$this->finalDN]['add']);
}
if (isset($attributes[$this->finalDN]['notchanged']) && is_array($attributes[$this->finalDN]['notchanged'])) {
$attr = array_merge_recursive($attr, $attributes[$this->finalDN]['notchanged']);
}
if (isset($attributes[$this->finalDN]['modify']) && is_array($attributes[$this->finalDN]['modify'])) {
$attr = array_merge_recursive($attr, $attributes[$this->finalDN]['modify']);
}
2013-10-16 17:37:17 +00:00
$success = @ldap_add($_SESSION['ldap']->server(), $this->finalDN, $attr);
2006-05-07 08:49:47 +00:00
if (!$success) {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_ERR, 'Unable to create DN: ' . $this->finalDN . ' (' . ldap_error($_SESSION['ldap']->server()) . '). '
2013-10-16 17:37:17 +00:00
. getExtendedLDAPErrorMessage($_SESSION['ldap']->server()));
$errors[] = array('ERROR', sprintf(_('Was unable to create DN: %s.'), $this->finalDN), getDefaultLDAPErrorString($_SESSION['ldap']->server()));
2006-05-07 08:49:47 +00:00
$stopprocessing = true;
}
2006-05-16 15:18:24 +00:00
else {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_NOTICE, 'Created DN: ' . $this->finalDN);
2006-05-16 15:18:24 +00:00
}
2008-02-23 10:23:40 +00:00
unset($attributes[$this->finalDN]);
2004-02-07 18:34:26 +00:00
}
}
2004-02-07 18:34:26 +00:00
$DNs = array_keys($attributes);
for ($i=0; $i<count($DNs); $i++) {
if (!$stopprocessing) {
logNewMessage(LOG_DEBUG, 'Attribute changes for ' . $DNs[$i] . ":\n" . print_r($attributes[$DNs[$i]], true));
2015-05-25 09:30:15 +00:00
// modify attributes
2013-12-04 18:11:49 +00:00
if (!empty($attributes[$DNs[$i]]['modify']) && !$stopprocessing) {
$success = @ldap_mod_replace($_SESSION['ldap']->server(), $DNs[$i], $attributes[$DNs[$i]]['modify']);
2004-02-07 18:34:26 +00:00
if (!$success) {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_ERR, 'Unable to modify attributes of DN: ' . $DNs[$i] . ' (' . ldap_error($_SESSION['ldap']->server()) . '). '
2013-10-16 17:37:17 +00:00
. getExtendedLDAPErrorMessage($_SESSION['ldap']->server()));
2019-09-26 16:40:16 +00:00
logNewMessage(LOG_DEBUG, print_r($attributes[$DNs[$i]]['modify'], true));
2013-10-16 17:37:17 +00:00
$errors[] = array('ERROR', sprintf(_('Was unable to modify attributes of DN: %s.'), $DNs[$i]), getDefaultLDAPErrorString($_SESSION['ldap']->server()));
2004-02-07 18:34:26 +00:00
$stopprocessing = true;
}
2006-05-16 15:18:24 +00:00
else {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_NOTICE, 'Modified DN: ' . $DNs[$i]);
// check if the password of the currently logged in user was changed
2019-08-05 19:56:06 +00:00
$lamAdmin = $_SESSION['ldap']->getUserName();
if ((strtolower($DNs[$i]) == strtolower($lamAdmin)) && isset($attributes[$DNs[$i]]['info']['userPasswordClearText'][0])) {
$_SESSION['ldap']->encrypt_login($DNs[$i], $attributes[$DNs[$i]]['info']['userPasswordClearText'][0]);
}
2006-05-16 15:18:24 +00:00
}
}
2004-02-07 18:34:26 +00:00
// add attributes
2013-12-04 18:11:49 +00:00
if (!empty($attributes[$DNs[$i]]['add']) && !$stopprocessing) {
$success = @ldap_mod_add($_SESSION['ldap']->server(), $DNs[$i], $attributes[$DNs[$i]]['add']);
2004-02-07 18:34:26 +00:00
if (!$success) {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_ERR, 'Unable to add attributes to DN: ' . $DNs[$i] . ' (' . ldap_error($_SESSION['ldap']->server()) . '). '
2013-10-16 17:37:17 +00:00
. getExtendedLDAPErrorMessage($_SESSION['ldap']->server()));
$errors[] = array('ERROR', sprintf(_('Was unable to add attributes to DN: %s.'), $DNs[$i]), getDefaultLDAPErrorString($_SESSION['ldap']->server()));
2004-02-07 18:34:26 +00:00
$stopprocessing = true;
}
2006-05-16 15:18:24 +00:00
else {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_NOTICE, 'Modified DN: ' . $DNs[$i]);
2006-05-16 15:18:24 +00:00
}
}
2005-12-05 14:27:47 +00:00
// remove attributes
2013-12-04 18:11:49 +00:00
if (!empty($attributes[$DNs[$i]]['remove']) && !$stopprocessing) {
$success = @ldap_mod_del($_SESSION['ldap']->server(), $DNs[$i], $attributes[$DNs[$i]]['remove']);
2004-02-07 18:34:26 +00:00
if (!$success) {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_ERR, 'Unable to delete attributes from DN: ' . $DNs[$i] . ' (' . ldap_error($_SESSION['ldap']->server()) . '). '
2013-10-16 17:37:17 +00:00
. getExtendedLDAPErrorMessage($_SESSION['ldap']->server()));
$errors[] = array('ERROR', sprintf(_('Was unable to remove attributes from DN: %s.'), $DNs[$i]), getDefaultLDAPErrorString($_SESSION['ldap']->server()));
2004-02-07 18:34:26 +00:00
$stopprocessing = true;
}
2006-05-16 15:18:24 +00:00
else {
2019-08-05 19:56:06 +00:00
logNewMessage(LOG_NOTICE, 'Modified DN: ' . $DNs[$i]);
2006-05-16 15:18:24 +00:00
}
2004-02-07 18:34:26 +00:00
}
}
}
// send password mail
if (!$stopprocessing && isLAMProVersion() && ($this->sendPasswordViaMail != null)) {
$mailMessages = sendPasswordMail($this->sendPasswordViaMail, $prePostModifyAttributes, $this->sendPasswordViaMailAlternateAddress);
if (sizeof($mailMessages) > 0) {
$errors = array_merge($errors, $mailMessages);
}
$this->sendPasswordViaMail = null;
$this->sendPasswordViaMailAlternateAddress = null;
}
2004-02-07 18:34:26 +00:00
if (!$stopprocessing) {
// post modify actions
foreach ($module as $singlemodule) {
2012-01-04 19:08:19 +00:00
$postMessages = $this->module[$singlemodule]->postModifyActions($this->isNewAccount, $prePostModifyAttributes);
$errors = array_merge($errors, $postMessages);
2004-02-07 18:34:26 +00:00
}
}
2006-08-27 14:57:22 +00:00
return $errors;
}
2004-02-07 18:34:26 +00:00
2016-01-06 15:05:52 +00:00
/**
* Defines if the LDAP entry has only virtual child entries. This is the case for e.g. LDAP views.
*
* @return boolean has only virtual children
*/
public function hasOnlyVirtualChildren() {
foreach ($this->module as $module) {
if ($module->hasOnlyVirtualChildren()) {
return true;
}
}
return false;
}
/**
* Returns a list of possible PDF entries for this account.
2006-08-14 17:29:45 +00:00
*
2015-01-07 17:16:35 +00:00
* @param array $pdfKeys list of PDF keys that are included in document
2017-04-01 07:57:03 +00:00
* @param string $typeId type id (user, group, host)
2017-02-19 08:14:11 +00:00
* @return PDFEntry[] list of key => PDFEntry
*/
2017-04-01 07:57:03 +00:00
function get_pdfEntries($pdfKeys, $typeId) {
$return = array();
while(($current = current($this->module)) != null) {
2017-04-01 07:57:03 +00:00
$return = array_merge($return,$current->get_pdfEntries($pdfKeys, $typeId));
next($this->module);
}
2010-01-13 18:55:22 +00:00
$dn = $this->dn_orig;
if (isset($this->finalDN)) {
$dn = $this->finalDN;
}
2019-01-02 20:10:32 +00:00
return array_merge($return,array('main_dn' => array(new \LAM\PDF\PDFLabelValue(_('DN'), $dn))));
}
2005-08-23 12:16:58 +00:00
/**
* Sorts the module buttons for the account page.
*/
function sortModules() {
$order = array();
$modules = array_keys($this->module);
$depModules = array();
2011-09-23 09:44:38 +00:00
if (isset($this->order)) {
$currentPage = $this->order[$this->current_page];
}
2005-08-23 12:16:58 +00:00
for ($i = 0; $i < sizeof($modules); $i++) {
// insert waiting modules
for ($w = 0; $w < sizeof($depModules); $w++) {
2016-12-24 14:39:02 +00:00
$dependencies = $this->module[$depModules[$w]]->get_dependencies($this->type->getScope());
2005-08-23 12:16:58 +00:00
$dependencies = $dependencies['depends'];
$everything_found = true;
for ($d = 0; $d < sizeof($dependencies); $d++) {
if (!in_array($dependencies[$d], $order)) {
$everything_found = false;
break;
}
}
// inser after depending module
if ($everything_found) {
$order[] = $depModules[$w];
unset($depModules[$w]);
$depModules = array_values($depModules);
$w--;
}
}
// check next module
2016-12-24 14:39:02 +00:00
$dependencies = $this->module[$modules[$i]]->get_dependencies($this->type->getScope());
2005-08-23 12:16:58 +00:00
if (is_array($dependencies['depends'])) {
$everything_found = true;
$dependencies = $dependencies['depends'];
for ($d = 0; $d < sizeof($dependencies); $d++) {
if (is_array($dependencies[$d])) { // or-combined dependencies
$noneFound = true;
foreach ($dependencies[$d] as $or) {
if (in_array($or, $order)) {
$noneFound = false;
break;
}
}
if ($noneFound) {
$everything_found = false;
break;
}
}
elseif (!in_array($dependencies[$d], $order)) { // single dependency
2005-08-23 12:16:58 +00:00
$everything_found = false;
break;
}
}
// remove module if dependencies are not satisfied
if (!$everything_found) {
$depModules[] = $modules[$i];
unset($modules[$i]);
$modules = array_values($modules);
$i--;
}
else {
$order[] = $modules[$i];
}
}
else {
$order[] = $modules[$i];
}
}
// add modules which could not be sorted (e.g. because of cyclic dependencies)
if (sizeof($depModules) > 0) {
2019-01-02 20:10:32 +00:00
for ($i = 0; $i < sizeof($depModules); $i++) {
$order[] = $depModules[$i];
}
2005-08-23 12:16:58 +00:00
}
2008-03-25 17:48:16 +00:00
// move disabled modules to end
$activeModules = array();
$passiveModules = array();
for ($i = 0; $i < sizeof($order); $i++) {
if ($this->module[$order[$i]]->getButtonStatus() == 'enabled') {
$activeModules[] = $order[$i];
}
else {
$passiveModules[] = $order[$i];
}
}
$this->order = array_merge($activeModules, $passiveModules);
2011-09-23 09:44:38 +00:00
// check if ordering changed and current page number must be updated
if (isset($currentPage) && ($currentPage != $this->order[$this->current_page])) {
$this->current_page = array_search($currentPage, $this->order);
}
2005-08-23 12:16:58 +00:00
}
2015-06-24 17:40:20 +00:00
2007-05-13 13:02:32 +00:00
/**
* Returns the RDN part of a given DN.
*
* @param String $dn DN
* @return String RDN
*/
function getRDN($dn) {
2019-01-02 20:10:32 +00:00
if (($dn == "") || ($dn == null)) {
return "";
}
return substr($dn, 0, strpos($dn, ","));
2007-05-13 13:02:32 +00:00
}
2015-06-24 17:40:20 +00:00
2007-05-13 13:02:32 +00:00
/**
* Returns the parent DN of a given DN.
*
* @param String $dn DN
* @return String DN
*/
function getParentDN($dn) {
2019-01-02 20:10:32 +00:00
if (($dn == "") || ($dn == null)) {
return "";
}
return substr($dn, strpos($dn, ",") + 1);
2007-05-13 13:02:32 +00:00
}
2015-06-24 17:40:20 +00:00
2010-11-21 14:32:54 +00:00
/**
* Returns a list of OUs that exist for this account type.
*
* @return array OU list
*/
2014-02-22 13:03:01 +00:00
public function getOUs() {
2010-11-21 14:32:54 +00:00
if ($this->cachedOUs != null) {
return $this->cachedOUs;
}
2016-12-31 13:44:46 +00:00
$this->cachedOUs = $this->type->getSuffixList();
2010-11-21 14:32:54 +00:00
return $this->cachedOUs;
}
2006-08-14 17:29:45 +00:00
2016-11-19 18:20:44 +00:00
/**
* Replaces POST data with wildcard values from modules.
*
* @param array $keyPrefixes POST keys as full name or prefix (e.g. "key" matches "key1")
*/
public function replaceWildcardsInPOST($keyPrefixes) {
$replacements = array();
foreach ($this->module as $module) {
$replacements = array_merge($replacements, $module->getWildCardReplacements());
}
while (true) {
if (!$this->replaceWildcards($replacements, $keyPrefixes, $_POST)) {
break;
}
}
}
/**
* Replaces wildcards in an array.
*
* @param array $replacements replacements (key => value)
* @param array $keyPrefixes prefixes of $data array keys that should be replaced
* @param array $data data array
* @return boolean replacement done
*/
private function replaceWildcards($replacements, $keyPrefixes, &$data) {
$found = false;
foreach ($data as $key => $value) {
foreach ($keyPrefixes as $keyPrefix) {
if (strpos($key, $keyPrefix) === 0) {
$found = $this->doReplace($replacements, $data[$key]) || $found;
}
}
}
return $found;
}
/**
* Replaces wildcards in a value.
*
* @param array $replacements replacements (key => value)
* @param String $value value to perform replacements
* @return boolean replacement done
*/
private function doReplace($replacements, &$value) {
$found = false;
foreach ($replacements as $replKey => $replValue) {
$searchString = '$' . $replKey;
if (strpos($value, $searchString) !== false) {
$found = true;
$value = str_replace($searchString, $replValue, $value);
}
}
return $found;
}
/**
* Encrypts sensitive data before storing in session.
*
* @return array list of attributes which are serialized
*/
function __sleep() {
// encrypt data
$this->attributes = lamEncrypt(serialize($this->attributes));
$this->attributes_orig = lamEncrypt(serialize($this->attributes_orig));
$this->module = lamEncrypt(serialize($this->module));
// save all attributes
2005-09-04 12:49:26 +00:00
return array_keys(get_object_vars($this));
}
2006-08-14 17:29:45 +00:00
/**
* Decrypts sensitive data after accountContainer was loaded from session.
*/
function __wakeup() {
// decrypt data
$this->attributes = unserialize(lamDecrypt($this->attributes));
$this->attributes_orig = unserialize(lamDecrypt($this->attributes_orig));
$this->module = unserialize(lamDecrypt($this->module));
2004-02-07 18:34:26 +00:00
}
}
/**
* This interface needs to be implemented by all account modules which manage passwords.
* It allows LAM to provide central password changes.
*
* @package modules
*/
interface passwordService {
2015-06-24 17:40:20 +00:00
/**
* This method specifies if a module manages password attributes. The module alias will
2015-06-24 17:40:20 +00:00
* then appear as option in the GUI.
* <br>If the module only wants to get notified about password changes then return false.
*
* @return boolean true if this module manages password attributes
*/
public function managesPasswordAttributes();
2015-06-24 17:40:20 +00:00
/**
* Specifies if this module supports to force that a user must change his password on next login.
2015-06-24 17:40:20 +00:00
*
* @return boolean force password change supported
*/
public function supportsForcePasswordChange();
2015-06-24 17:40:20 +00:00
/**
2009-10-09 18:21:12 +00:00
* This function is called whenever the password should be changed. Account modules
* must change their password attributes only if the modules list contains their module name.
*
* @param String $password new password
* @param array $modules list of modules for which the password should be changed
* @param boolean $forcePasswordChange force the user to change his password at next login
* @return array list of error messages if any as parameter array for StatusMessage
2020-02-24 19:08:28 +00:00
* e.g. return array(array('ERROR', 'Password change failed.'))
*/
public function passwordChangeRequested($password, $modules, $forcePasswordChange);
}
2004-09-08 10:07:25 +00:00
?>