2004-01-30 10:26:04 +00:00
|
|
|
<?php
|
|
|
|
/*
|
|
|
|
$Id$
|
|
|
|
|
|
|
|
This code is part of LDAP Account Manager (http://www.sourceforge.net/projects/lam)
|
2004-01-31 10:35:34 +00:00
|
|
|
Copyright (C) 2003 - 2004 Roland Gruber
|
2004-01-30 10:26:04 +00:00
|
|
|
|
|
|
|
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-01-30 10:26:04 +00:00
|
|
|
|
2004-06-20 19:23:04 +00:00
|
|
|
/**
|
|
|
|
* Interface between modules and other parts of LAM.
|
|
|
|
*
|
|
|
|
* @package modules
|
|
|
|
* @author Tilo Lutz
|
|
|
|
* @author Michael Duergner
|
|
|
|
* @author Roland Gruber
|
2004-01-30 10:26:04 +00:00
|
|
|
*/
|
|
|
|
|
2004-06-20 19:23:04 +00:00
|
|
|
/** LDAP caches */
|
2004-04-03 14:47:33 +00:00
|
|
|
include_once("cache.inc");
|
2004-06-20 19:23:04 +00:00
|
|
|
/** some helper functions */
|
2004-04-04 13:45:59 +00:00
|
|
|
include_once("account.inc");
|
2004-06-08 18:54:37 +00:00
|
|
|
/** parent class of account modules */
|
|
|
|
include_once("baseModule.inc");
|
2004-09-08 19:30:18 +00:00
|
|
|
/** access to LDAP server */
|
|
|
|
include_once("ldap.inc");
|
2004-12-09 19:10:57 +00:00
|
|
|
/** lamdaemon functions */
|
|
|
|
include_once("lamdaemon.inc");
|
2004-09-08 19:30:18 +00:00
|
|
|
|
2004-06-20 19:23:04 +00:00
|
|
|
/**
|
|
|
|
* This includes all module files.
|
2004-02-10 19:59:41 +00:00
|
|
|
*/
|
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.
|
|
|
|
while ($entry = $modulesINC_dir->read())
|
|
|
|
if ((substr($entry, strlen($entry) - 4, 4) == '.inc') && is_file($modulesINC_dirname . '/'.$entry)) {
|
|
|
|
include_once($modulesINC_dirname . '/'.$entry);
|
2004-07-24 17:14:39 +00:00
|
|
|
}
|
2004-01-30 10:26:04 +00:00
|
|
|
|
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
|
|
|
|
*/
|
2004-02-21 17:25:18 +00:00
|
|
|
function getModuleAlias($name, $scope) {
|
2004-06-14 16:05:36 +00:00
|
|
|
$module = new $name($scope);
|
|
|
|
return $module->get_alias();
|
2004-02-21 17:25:18 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
*/
|
2004-02-21 17:25:18 +00:00
|
|
|
function is_base_module($name, $scope) {
|
2004-06-08 18:54:37 +00:00
|
|
|
$module = new $name($scope);
|
|
|
|
return $module->is_base_module();
|
2004-02-21 17:25:18 +00:00
|
|
|
}
|
2004-01-30 10:26:04 +00:00
|
|
|
|
2004-06-20 19:23:04 +00:00
|
|
|
/**
|
|
|
|
* Returns the LDAP filter used by the account lists
|
|
|
|
*
|
|
|
|
* @param string $scope the account type ("user", "group", "host")
|
|
|
|
* @return string LDAP filter
|
|
|
|
*/
|
2004-02-23 16:55:51 +00:00
|
|
|
function get_ldap_filter($scope) {
|
2004-10-17 09:52:58 +00:00
|
|
|
$mods = $_SESSION['config']->get_AccountModules($scope);
|
2004-02-23 16:55:51 +00:00
|
|
|
$filters = array();
|
2004-06-04 11:28:22 +00:00
|
|
|
$orFilter = '';
|
2004-02-23 16:55:51 +00:00
|
|
|
for ($i = 0; $i < sizeof($mods); $i++) {
|
2005-01-10 10:57:04 +00:00
|
|
|
$module = new $mods[$i]($scope);
|
|
|
|
$modinfo = $module->get_ldap_filter();
|
|
|
|
if (isset($modinfo['or'])) $filters['or'][] = $modinfo['or'];
|
|
|
|
if (isset($modinfo['and'])) $filters['and'][] = $modinfo['and'];
|
2004-02-23 16:55:51 +00:00
|
|
|
}
|
2004-06-04 11:28:22 +00:00
|
|
|
// build OR filter
|
|
|
|
if (sizeof($filters['or']) == 1) {
|
|
|
|
$orFilter = $filters['or'][0];
|
2004-02-23 16:55:51 +00:00
|
|
|
}
|
2004-06-04 11:28:22 +00:00
|
|
|
elseif (sizeof($filters['or']) > 1) {
|
|
|
|
$orFilter = "(|" . implode("", $filters['or']) . ")";
|
2004-02-23 16:55:51 +00:00
|
|
|
}
|
2004-06-04 11:28:22 +00:00
|
|
|
// add built OR filter to AND filters
|
|
|
|
if ($orFilter != '') $filters['and'][] = $orFilter;
|
|
|
|
// collapse AND filters
|
|
|
|
if (sizeof($filters['and']) < 2) return $filters['and'][0];
|
|
|
|
else return "(&" . implode("", $filters['and']) . ")";
|
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.
|
|
|
|
*
|
|
|
|
* @param string $scope account type (user, group, host)
|
|
|
|
* @return array list of LDAP attributes
|
|
|
|
*/
|
|
|
|
function getRDNAttributes($scope) {
|
2004-10-17 09:52:58 +00:00
|
|
|
$mods = $_SESSION['config']->get_AccountModules($scope);
|
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
|
|
|
|
$module = new $mods[$i]($scope);
|
|
|
|
$attrs = $module->get_RDNAttributes();
|
|
|
|
$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
|
2005-08-13 09:49:28 +00:00
|
|
|
$return = array_values(array_unique($attrs_high));
|
|
|
|
for ($i = 0; $i < sizeof($attrs_normal); $i++) {
|
|
|
|
if (!in_array($attrs_normal[$i], $return)) $return[] = $attrs_normal[$i];
|
|
|
|
}
|
|
|
|
for ($i = 0; $i < sizeof($attrs_low); $i++) {
|
|
|
|
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) {
|
2004-06-04 11:28:22 +00:00
|
|
|
$mods = getAvailableModules($scope);
|
|
|
|
for ($i = 0; $i < sizeof($mods); $i++) {
|
2004-06-20 17:32:02 +00:00
|
|
|
$module = new $mods[$i]($scope);
|
|
|
|
$return[$mods[$i]] = $module->get_dependencies();
|
2004-06-04 11:28:22 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
return $return;
|
2004-07-24 17:14:39 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
|
2004-01-30 10:26:04 +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
|
|
|
|
* @return mixed false if no misssing dependency was found,
|
|
|
|
* otherwise an array of array(selected module, depending module) if missing dependencies were found
|
|
|
|
*/
|
2004-02-21 17:25:18 +00:00
|
|
|
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]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sizeof($ret) > 0) return $ret;
|
|
|
|
else 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
|
2005-07-21 11:22:59 +00:00
|
|
|
* @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
|
|
|
|
*/
|
2004-02-21 17:25:18 +00:00
|
|
|
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]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sizeof($ret) > 0) return $ret;
|
|
|
|
else 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)
|
|
|
|
* @return array list of possible modules
|
|
|
|
*/
|
2004-02-07 18:34:26 +00:00
|
|
|
function getAvailableModules($scope) {
|
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.
|
2004-10-14 14:09:44 +00:00
|
|
|
while ($entry = $dir->read())
|
|
|
|
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, '.'));
|
2004-06-13 19:58:58 +00:00
|
|
|
$temp = new $entry($scope);
|
|
|
|
if ($temp->can_manage()) $return[] = $entry;
|
2004-03-02 19:58:17 +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.
|
|
|
|
*
|
|
|
|
* @param string $scope account type (user, group, host)
|
|
|
|
* @return array profile elements
|
|
|
|
*/
|
2004-03-06 19:15:40 +00:00
|
|
|
function getProfileOptions($scope) {
|
2004-10-28 19:37:40 +00:00
|
|
|
$mods = $_SESSION['config']->get_AccountModules($scope);
|
|
|
|
$return = array();
|
|
|
|
for ($i = 0; $i < sizeof($mods); $i++) {
|
|
|
|
$module = new $mods[$i]($scope);
|
|
|
|
$return[$mods[$i]] = $module->get_profileOptions();
|
2004-02-08 15:57:55 +00:00
|
|
|
}
|
2004-10-28 19:37:40 +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
|
|
|
|
*
|
|
|
|
* @param string $scope account type (user, group, host)
|
|
|
|
* @param array $options hash array containing all options (name => array(...))
|
|
|
|
* @return array list of error messages
|
|
|
|
*/
|
2004-03-14 17:35:22 +00:00
|
|
|
function checkProfileOptions($scope, $options) {
|
2004-10-28 19:37:40 +00:00
|
|
|
$mods = $_SESSION['config']->get_AccountModules($scope);
|
|
|
|
$return = array();
|
|
|
|
for ($i = 0; $i < sizeof($mods); $i++) {
|
|
|
|
$module = new $mods[$i]($scope);
|
|
|
|
$temp = $module->check_profileOptions($options);
|
|
|
|
$return = array_merge($return, $temp);
|
2004-02-08 15:57:55 +00:00
|
|
|
}
|
2004-10-28 19:37:40 +00:00
|
|
|
return $return;
|
2004-03-14 17:35:22 +00:00
|
|
|
}
|
2004-02-21 17:25:18 +00:00
|
|
|
|
2004-07-24 17:14:39 +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++) {
|
|
|
|
$m = new $modules[$i]('none');
|
|
|
|
$return[$modules[$i]] = $m->get_configOptions($scopes[$modules[$i]]);
|
|
|
|
}
|
|
|
|
return $return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a hash array (module name => descriptions) containing descriptions shown on configuration pages.
|
|
|
|
*
|
|
|
|
* The returned array has the format array('legend' => array('posixAccount' => '...', ...), descriptions => array('option1' => '...', ...)).
|
|
|
|
* <br> The "legend" value is used as text for the fieldset, the descriptions are used when the configuration is printed.
|
|
|
|
*
|
|
|
|
* @return array configuration descriptions
|
|
|
|
*/
|
|
|
|
function getConfigDescriptions() {
|
|
|
|
$return = array('legend' => array(), 'descriptions' => array());
|
2006-01-01 16:30:05 +00:00
|
|
|
$modules = array();
|
|
|
|
$types = $_SESSION['config']->get_ActiveTypes();
|
|
|
|
for ($i = 0; $i < sizeof($types); $i++) {
|
|
|
|
$modules = array_merge($modules, getAvailableModules($types[$i]));
|
|
|
|
}
|
2004-07-24 17:14:39 +00:00
|
|
|
$modules = array_merge(getAvailableModules('user'), getAvailableModules('group'), getAvailableModules('host'));
|
|
|
|
$modules = array_values(array_unique($modules));
|
|
|
|
for ($i = 0; $i < sizeof($modules); $i++) {
|
|
|
|
$m = new $modules[$i]('none');
|
|
|
|
$desc = $m->get_configDescriptions();
|
|
|
|
$return['legend'][$modules[$i]] = $desc['legend'];
|
|
|
|
$return['descriptions'] = array_merge($return['descriptions'], $desc['descriptions']);
|
|
|
|
}
|
|
|
|
return $return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if the configuration options are valid
|
|
|
|
*
|
|
|
|
* @param array $scopes hash array (module name => array(account types))
|
|
|
|
* @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++) {
|
|
|
|
$m = new $modules[$i]('none');
|
|
|
|
$errors = $m->check_configOptions($scopes[$modules[$i]], $options);
|
|
|
|
$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 $helpID help identifier
|
|
|
|
* @param string $module module name
|
|
|
|
* @return array help entry
|
|
|
|
*/
|
2004-09-09 07:10:14 +00:00
|
|
|
function getHelp($module,$helpID,$scope='') {
|
|
|
|
$moduleObject = new $module((($scope != '') ? $scope : 'none'));
|
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.
|
|
|
|
*
|
|
|
|
* @param string $scope account type (user, group, host)
|
|
|
|
* @return array PDF entries
|
|
|
|
*/
|
2004-05-30 13:43:42 +00:00
|
|
|
function getAvailablePDFFields($scope) {
|
2005-06-19 09:40:30 +00:00
|
|
|
$mods = $_SESSION['config']->get_AccountModules($scope);
|
|
|
|
$return = array();
|
|
|
|
for ($i = 0; $i < sizeof($mods); $i++) {
|
|
|
|
$module = new $mods[$i]($scope);
|
|
|
|
$return[$mods[$i]] = $module->get_pdfFields();
|
2004-05-30 13:43:42 +00:00
|
|
|
}
|
2005-06-19 09:40:30 +00:00
|
|
|
$return['main'] = array('dn');
|
|
|
|
return $return;
|
2004-05-30 13:43:42 +00:00
|
|
|
}
|
|
|
|
|
2004-09-08 19:30:18 +00:00
|
|
|
/**
|
|
|
|
* 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> )
|
|
|
|
*
|
|
|
|
* @param string $scope account type
|
|
|
|
* @return array column list
|
|
|
|
*/
|
|
|
|
function getUploadColumns($scope) {
|
2004-10-28 19:37:40 +00:00
|
|
|
$mods = $_SESSION['config']->get_AccountModules($scope);
|
|
|
|
$return = array();
|
|
|
|
for ($i = 0; $i < sizeof($mods); $i++) {
|
|
|
|
$module = new $mods[$i]($scope);
|
|
|
|
$return[$mods[$i]] = $module->get_uploadColumns();
|
2004-09-08 19:30:18 +00:00
|
|
|
}
|
2004-10-28 19:37:40 +00:00
|
|
|
return $return;
|
2004-09-08 19:30:18 +00:00
|
|
|
}
|
|
|
|
|
2004-09-19 08:26:33 +00:00
|
|
|
/**
|
|
|
|
* This function builds the LDAP accounts for the file upload.
|
|
|
|
*
|
|
|
|
* If there are problems status messages will be printed automatically.
|
|
|
|
*
|
|
|
|
* @param string $scope account type
|
|
|
|
* @param array $data array containing one account in each element
|
|
|
|
* @param array $ids array(<column_name> => <column number>)
|
|
|
|
* @return mixed array including accounts or false if there were errors
|
|
|
|
*/
|
|
|
|
function buildUploadAccounts($scope, $data, $ids) {
|
|
|
|
// build module order
|
2004-10-17 09:52:58 +00:00
|
|
|
$unOrdered = $_SESSION['config']->get_AccountModules($scope);
|
2004-09-19 08:26:33 +00:00
|
|
|
$ordered = array();
|
|
|
|
$predepends = array();
|
2004-10-17 09:36:36 +00:00
|
|
|
// get dependencies
|
2004-09-19 08:26:33 +00:00
|
|
|
for ($i = 0; $i < sizeof($unOrdered); $i++) {
|
|
|
|
$mod = new $unOrdered[$i]($scope);
|
|
|
|
$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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ($newRound) continue;
|
|
|
|
// this point should never be reached, LAM was unable to find a correct module order
|
2004-10-23 11:53:30 +00:00
|
|
|
StatusMessage("ERROR", "Internal Error: Unable to find correct module order.", "");
|
2004-09-19 08:26:33 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// give raw data to modules
|
|
|
|
$errors = array();
|
|
|
|
$partialAccounts = array();
|
2004-09-21 18:32:44 +00:00
|
|
|
for ($i = 0; $i < sizeof($data); $i++) $partialAccounts[$i]['objectClass'] = array();
|
2004-09-19 08:26:33 +00:00
|
|
|
for ($i = 0; $i < sizeof($ordered); $i++) {
|
|
|
|
$module = new $ordered[$i]($scope);
|
2004-09-19 16:04:37 +00:00
|
|
|
$errors = $module->build_uploadAccounts($data, $ids, $partialAccounts);
|
|
|
|
if (sizeof($errors) > 0) {
|
2004-10-17 15:55:26 +00:00
|
|
|
array_unshift($errors, array("INFO", _("Displayed account numbers start at \"0\". Add 2 to get the row in your spreadsheet."), ""));
|
2004-10-09 11:08:16 +00:00
|
|
|
$errors[] = array("ERROR", _("Upload was stopped after errors in %s module!"), "", array($module->get_alias()));
|
2004-09-19 16:04:37 +00:00
|
|
|
break;
|
|
|
|
}
|
2004-09-19 08:26:33 +00:00
|
|
|
}
|
2004-09-19 16:04:37 +00:00
|
|
|
if (sizeof($errors) > 0) {
|
2004-10-09 11:08:16 +00:00
|
|
|
for ($i = 0; (($i < sizeof($errors)) || ($i > 49)); $i++) call_user_func_array("StatusMessage", $errors[$i]);
|
2004-09-19 16:04:37 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else return $partialAccounts;
|
2004-09-19 08:26:33 +00:00
|
|
|
}
|
2004-09-08 19:30:18 +00:00
|
|
|
|
2004-10-19 18:18:46 +00:00
|
|
|
/**
|
|
|
|
* This function executes one post upload action.
|
|
|
|
*
|
|
|
|
* @param string $scope account type
|
|
|
|
* @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
|
|
|
|
* @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> )
|
|
|
|
*/
|
|
|
|
function doUploadPostActions($scope, $data, $ids, $failed) {
|
|
|
|
// check if function is called the first time
|
|
|
|
if (! isset($_SESSION['mass_postActions']['remainingModules'])) {
|
|
|
|
// make list of remaining modules
|
|
|
|
$moduleList = $_SESSION['config']->get_AccountModules($scope);
|
|
|
|
$_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
|
|
|
|
$module = new $activeModule($scope);
|
|
|
|
$return = $module->doUploadPostActions($data, $ids, $failed, $_SESSION['mass_postActions'][$activeModule]);
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
2005-03-29 10:05:08 +00:00
|
|
|
/**
|
|
|
|
* Takes a list of meta-HTML elements and prints the equivalent HTML output.
|
|
|
|
*
|
|
|
|
* @param string $module Name of account module
|
|
|
|
* @param array $input List of meta-HTML 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 integer $tabindexLink Start value of tabulator index for links
|
2005-03-29 16:10:30 +00:00
|
|
|
* @param string $scope Account type
|
2005-03-29 14:33:31 +00:00
|
|
|
* @return array List of input field names and their type (name => type)
|
2005-03-29 10:05:08 +00:00
|
|
|
*/
|
2005-03-29 16:10:30 +00:00
|
|
|
function parseHtml($module, $input, $values, $restricted, &$tabindex, &$tabindexLink, $scope) {
|
2005-03-29 14:33:31 +00:00
|
|
|
$ret = array();
|
2005-03-29 10:05:08 +00:00
|
|
|
if (is_array($input)) {
|
|
|
|
echo "<table>\n";
|
|
|
|
for ($i=0; $i<count($input); $i++) { // $i = row number
|
|
|
|
// Draw column
|
|
|
|
echo "<tr>\n";
|
|
|
|
for ($j=0; $j<count($input[$i]); $j++ ) { // $j = column number
|
|
|
|
// Draw cell
|
|
|
|
echo "<td";
|
|
|
|
if (isset($input[$i][$j]['td']['align'])) echo " align=\"" . $input[$i][$j]['td']['align'] . "\"";
|
|
|
|
if (isset($input[$i][$j]['td']['valign'])) echo " valign=\"" . $input[$i][$j]['td']['valign'] . "\"";
|
|
|
|
if (isset($input[$i][$j]['td']['colspan'])) echo " colspan=\"" . $input[$i][$j]['td']['colspan'] . "\"";
|
|
|
|
if (isset($input[$i][$j]['td']['rowspan'])) echo " rowspan=\"" . $input[$i][$j]['td']['rowspan'] . "\"";
|
2005-07-05 12:46:53 +00:00
|
|
|
if (isset($input[$i][$j]['td']['width'])) echo " width=\"" . $input[$i][$j]['td']['width'] . "\"";
|
2005-03-29 10:05:08 +00:00
|
|
|
echo ">\n";
|
|
|
|
switch ($input[$i][$j]['kind']) {
|
|
|
|
// plain text
|
|
|
|
case 'text':
|
|
|
|
echo $input[$i][$j]['text'];
|
|
|
|
break;
|
|
|
|
// input fields
|
|
|
|
case 'input':
|
2005-03-29 14:33:31 +00:00
|
|
|
$type = $input[$i][$j]['type'];
|
|
|
|
if ($restricted && (($type == "submit") || ($type == "reset") || ($type == "file"))) break; // no buttons in restricted mode
|
2005-03-29 10:05:08 +00:00
|
|
|
$output = "<input";
|
|
|
|
if ($input[$i][$j]['name']!='') $output .= ' name="' . $input[$i][$j]['name'] . '"';
|
2005-03-29 14:33:31 +00:00
|
|
|
if ($type != '') $output .= ' type="' . $type . '"';
|
2005-03-29 10:05:08 +00:00
|
|
|
if ($input[$i][$j]['size']!='') $output .= ' size="' . $input[$i][$j]['size'] . '"';
|
|
|
|
if ($input[$i][$j]['maxlength']!='') $output .= ' maxlength="' . $input[$i][$j]['maxlength'] . '"';
|
2005-03-29 14:33:31 +00:00
|
|
|
// checkbox
|
|
|
|
if ($type == "checkbox") {
|
|
|
|
if (isset($values[$input[$i][$j]['name']])) {
|
2005-03-29 16:10:30 +00:00
|
|
|
if ($values[$input[$i][$j]['name']][0] == "true") $output .= ' checked';
|
2005-03-29 14:33:31 +00:00
|
|
|
}
|
|
|
|
elseif ($input[$i][$j]['checked']) $output .= ' checked';
|
|
|
|
}
|
|
|
|
// other input element
|
|
|
|
else {
|
|
|
|
if (isset($values[$input[$i][$j]['name']])) {
|
2005-03-29 16:10:30 +00:00
|
|
|
$output .= ' value="' . $values[$input[$i][$j]['name']][0] . '"';
|
2005-03-29 14:33:31 +00:00
|
|
|
}
|
|
|
|
elseif ($input[$i][$j]['value']!='') $output .= ' value="' . $input[$i][$j]['value'] . '"';
|
|
|
|
}
|
2005-03-29 10:05:08 +00:00
|
|
|
if ($input[$i][$j]['disabled']) $output .= ' disabled';
|
|
|
|
// Show taborder
|
|
|
|
else {
|
|
|
|
$output .= " tabindex=$tabindex";
|
|
|
|
$tabindex++;
|
|
|
|
}
|
|
|
|
$output .= ">";
|
|
|
|
echo $output;
|
2005-03-29 14:33:31 +00:00
|
|
|
$ret[$input[$i][$j]['name']] = $type; // save type
|
2005-03-29 10:05:08 +00:00
|
|
|
break;
|
|
|
|
// inner fieldset
|
|
|
|
case 'fieldset':
|
|
|
|
echo "<fieldset>\n";
|
|
|
|
if ($input[$i][$j]['legend']!='') echo "<legend>" . $input[$i][$j]['legend'] . "</legend>\n";
|
2005-03-29 16:10:30 +00:00
|
|
|
parseHtml($module, $input[$i][$j]['value'], $values, $restricted, $tabindex, $tabindexLink, $scope);
|
2005-03-29 10:05:08 +00:00
|
|
|
echo "</fieldset>\n";
|
|
|
|
break;
|
|
|
|
// selection
|
|
|
|
case 'select':
|
2005-03-29 14:33:31 +00:00
|
|
|
if (! is_numeric($input[$i][$j]['size'])) $input[$i][$j]['size'] = 1; // correct size if needed
|
|
|
|
if (isset($input[$i][$j]['multiple'])) {
|
|
|
|
echo "<select name=\"" . $input[$i][$j]['name'] . '[]"';
|
|
|
|
echo ' multiple';
|
|
|
|
$ret[$input[$i][$j]['name']] = 'multiselect'; // save type
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
echo "<select name=\"" . $input[$i][$j]['name'] . '"';
|
|
|
|
$ret[$input[$i][$j]['name']] = 'select'; // save type
|
|
|
|
}
|
|
|
|
echo ' size="' . $input[$i][$j]['size'] . '"';
|
|
|
|
// Show taborder
|
|
|
|
echo " tabindex=$tabindex";
|
|
|
|
$tabindex++;
|
|
|
|
echo ">\n";
|
|
|
|
// init option fields
|
2005-03-29 10:05:08 +00:00
|
|
|
if (!is_array($input[$i][$j]['options'])) $input[$i][$j]['options'] = array ( $input[$i][$j]['options'] );
|
|
|
|
if (isset($input[$i][$j]['options_selected'])) {
|
|
|
|
if (!is_array($input[$i][$j]['options_selected'])) {
|
|
|
|
// one selected element
|
|
|
|
$input[$i][$j]['options_selected'] = array ( $input[$i][$j]['options_selected'] );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$input[$i][$j]['options_selected'] = array();
|
|
|
|
}
|
2005-03-29 14:33:31 +00:00
|
|
|
if (isset($values[$input[$i][$j]['name']])) $input[$i][$j]['options_selected'] = $values[$input[$i][$j]['name']];
|
2005-03-29 10:05:08 +00:00
|
|
|
// merge both option arrays and sort them.
|
|
|
|
$options = array_merge ($input[$i][$j]['options'], $input[$i][$j]['options_selected'] );
|
|
|
|
$options = array_unique($options);
|
2005-08-13 11:31:26 +00:00
|
|
|
if (!$input[$i][$j]['noSorting']) {
|
2005-10-25 18:17:01 +00:00
|
|
|
sort($options);
|
2005-08-13 11:31:26 +00:00
|
|
|
}
|
2005-03-29 10:05:08 +00:00
|
|
|
foreach ($options as $option) {
|
|
|
|
if ($option!='') {
|
|
|
|
if (in_array($option, $input[$i][$j]['options_selected'])) echo "<option selected>" . $option . "</option>\n";
|
|
|
|
else echo "<option>" . $option . "</option>\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
echo "</select>\n";
|
|
|
|
break;
|
|
|
|
// sub table
|
|
|
|
case 'table':
|
2005-07-11 18:53:53 +00:00
|
|
|
$retTemp = parseHtml($module, $input[$i][$j]['value'], $values, $restricted, $tabindex, $tabindexLink, $scope);
|
|
|
|
$ret = array_merge($ret, $retTemp);
|
2005-03-29 10:05:08 +00:00
|
|
|
break;
|
|
|
|
// help link
|
|
|
|
case 'help':
|
2005-04-05 12:04:37 +00:00
|
|
|
$helpPath = "../";
|
2005-04-23 16:54:34 +00:00
|
|
|
if (is_file("./help.php")) $helpPath = "";
|
|
|
|
echo "<a href=" . $helpPath . "help.php?module=$module&HelpNumber=". $input[$i][$j]['value'] . "&scope=" . $scope . " target=\"help\" tabindex=$tabindexLink>";
|
|
|
|
echo "<img src=\"../$helpPath/graphics/help.png\" alt=\"" . _('Help') . "\" title=\"" . _('Help') . "\">";
|
|
|
|
echo "</a>\n";
|
2005-03-29 10:05:08 +00:00
|
|
|
$tabindexLink++;
|
|
|
|
break;
|
|
|
|
// status message
|
|
|
|
case 'message':
|
|
|
|
StatusMessage($input[$i][$j]['type'], $input[$i][$j]['headline'], $input[$i][$j]['text']);
|
|
|
|
break;
|
|
|
|
// image
|
|
|
|
case 'image':
|
|
|
|
echo "<img ";
|
|
|
|
if (isset($input[$i][$j]['path'])) echo 'src="' . $input[$i][$j]['path'] . '" ';
|
|
|
|
if (isset($input[$i][$j]['width'])) echo 'width="' . $input[$i][$j]['width'] . '" ';
|
|
|
|
if (isset($input[$i][$j]['height'])) echo 'height="' . $input[$i][$j]['height'] . '" ';
|
|
|
|
if (isset($input[$i][$j]['alt'])) echo 'alt="' . $input[$i][$j]['alt'] . '" ';
|
|
|
|
echo ">\n";
|
|
|
|
break;
|
|
|
|
// error, unknown type
|
|
|
|
default:
|
|
|
|
echo "Unrecognized type: " . $input[$i][$j]['kind'] . "\n";
|
|
|
|
break;
|
|
|
|
}
|
2005-08-21 17:12:30 +00:00
|
|
|
echo "</td>\n";
|
2005-03-29 10:05:08 +00:00
|
|
|
}
|
|
|
|
echo "</tr>\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
echo "</table>\n";
|
2005-03-29 14:33:31 +00:00
|
|
|
return $ret;
|
2005-03-29 10:05:08 +00:00
|
|
|
}
|
2004-10-19 18:18:46 +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 {
|
2005-07-21 11:22:59 +00:00
|
|
|
/**
|
|
|
|
* Constructor
|
|
|
|
*
|
|
|
|
* @param string $type account type
|
|
|
|
* @param string $base key in $_SESSION where this object is saved
|
|
|
|
*/
|
2004-02-07 18:34:26 +00:00
|
|
|
function accountContainer($type, $base) {
|
|
|
|
/* Set the type of account. Valid
|
|
|
|
* types are: user, group, host
|
|
|
|
*/
|
|
|
|
// Check input variable
|
2004-09-15 19:52:29 +00:00
|
|
|
|
2004-10-23 11:11:31 +00:00
|
|
|
if (!is_string($type)) trigger_error('Argument of accountContainer must be string.', 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';
|
2005-04-29 15:20:48 +00:00
|
|
|
$this->isNewAccount = false;
|
2004-02-07 18:34:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-29 15:20:48 +00:00
|
|
|
/**
|
|
|
|
* Array of all used attributes
|
2004-02-07 18:34:26 +00:00
|
|
|
* Syntax is attribute => array ( objectClass => MUST or MAY, ...)
|
|
|
|
*/
|
|
|
|
var $attributes;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This variale stores the account type.
|
|
|
|
* Currently "user", "group" and "host" are supported.
|
2004-02-07 18:34:26 +00:00
|
|
|
*/
|
2004-04-03 14:47:33 +00:00
|
|
|
var $type;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
2005-07-21 11:22:59 +00:00
|
|
|
/** This is an array with all module objects */
|
|
|
|
var $module;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
2005-05-02 17:41:09 +00:00
|
|
|
/** DN suffix of the account */
|
2004-02-07 18:34:26 +00:00
|
|
|
var $dn;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
2005-05-02 17:41:09 +00:00
|
|
|
/** DN suffix of account when it was loaded */
|
2004-02-07 18:34:26 +00:00
|
|
|
var $dn_orig;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
2005-05-02 17:41:09 +00:00
|
|
|
/** RDN attribute of this account */
|
|
|
|
var $rdn;
|
|
|
|
|
|
|
|
/** original LDAP attributes when account was loaded from LDAP */
|
|
|
|
var $attributes_orig;
|
|
|
|
|
2005-04-29 15:20:48 +00:00
|
|
|
/** Module order */
|
2004-02-07 18:34:26 +00:00
|
|
|
var $order;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
|
|
|
/** Name of accountContainer variable in session */
|
2004-02-07 18:34:26 +00:00
|
|
|
var $base;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
|
|
|
/** This variable stores the name of the currently displayed page */
|
2004-09-08 10:07:25 +00:00
|
|
|
var $current_page;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
|
|
|
/** This variable is set to the pagename of a subpage if it should be displayed */
|
2004-09-08 10:07:25 +00:00
|
|
|
var $subpage;
|
2005-04-29 15:20:48 +00:00
|
|
|
|
|
|
|
/** True if this is a newly created account */
|
|
|
|
var $isNewAccount;
|
2004-02-07 18:34:26 +00:00
|
|
|
|
2004-09-08 10:07:25 +00:00
|
|
|
|
2005-07-21 11:22:59 +00:00
|
|
|
/**
|
|
|
|
* Returns the accout type of this object (e.g. user, group, host).
|
|
|
|
*
|
|
|
|
* @return string account type
|
2004-02-07 18:34:26 +00:00
|
|
|
*/
|
|
|
|
function get_type() {
|
|
|
|
return $this->type;
|
|
|
|
}
|
2004-09-08 10:07:25 +00:00
|
|
|
|
2005-07-21 11:22:59 +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.
|
|
|
|
*
|
|
|
|
* @param array $post HTTP POST variables
|
|
|
|
*/
|
2004-02-07 18:34:26 +00:00
|
|
|
function continue_main($post) {
|
2004-09-08 10:07:25 +00:00
|
|
|
if ($this->subpage=='') $this->subpage='attributes';
|
2004-02-07 18:34:26 +00:00
|
|
|
if ($post['form_main_reset']) {
|
|
|
|
$this->load_account($this->dn_orig);
|
|
|
|
}
|
|
|
|
else {
|
2004-09-08 10:07:25 +00:00
|
|
|
if ($this->current_page==0) {
|
|
|
|
if ($this->subpage=='attributes') {
|
|
|
|
$result = 0;
|
|
|
|
// change dn
|
|
|
|
if ($post['suffix']!='') $this->dn = $post['suffix'];
|
2005-05-02 17:41:09 +00:00
|
|
|
// change RDN
|
|
|
|
if (isset($post['rdn'])) $this->rdn = $post['rdn'];
|
2004-09-08 10:07:25 +00:00
|
|
|
|
|
|
|
// load profile
|
|
|
|
if ($post['selectLoadProfile'] && $post['loadProfile']) {
|
2005-01-07 10:55:05 +00:00
|
|
|
$profile = loadAccountProfile($post['selectLoadProfile'], $this->type);
|
|
|
|
// pass profile to each module
|
2004-09-08 10:07:25 +00:00
|
|
|
$modules = array_keys($this->module);
|
2005-01-07 10:55:05 +00:00
|
|
|
foreach ($modules as $module) $this->module[$module]->load_profile($profile);
|
2005-05-22 09:05:33 +00:00
|
|
|
if (isset($profile['ldap_rdn'][0])) {
|
2005-08-13 09:38:32 +00:00
|
|
|
if (in_array($profile['ldap_rdn'][0], getRDNAttributes($this->type))) {
|
|
|
|
$this->rdn = $profile['ldap_rdn'][0];
|
|
|
|
}
|
2005-05-22 09:05:33 +00:00
|
|
|
}
|
|
|
|
if (isset($profile['ldap_suffix'][0])) {
|
|
|
|
$this->dn = $profile['ldap_suffix'][0];
|
|
|
|
}
|
2004-09-08 10:07:25 +00:00
|
|
|
$result = 0;
|
2005-09-01 15:20:15 +00:00
|
|
|
}
|
2004-09-08 10:07:25 +00:00
|
|
|
// save account
|
|
|
|
if ($post['create']) {
|
|
|
|
$errors = $this->save_account();
|
2005-05-10 16:51:32 +00:00
|
|
|
if (is_array($errors)) {
|
|
|
|
$result = array($errors);
|
|
|
|
$stopProcessing = true;
|
|
|
|
}
|
2005-09-01 15:20:15 +00:00
|
|
|
else $this->subpage = 'finish';
|
2004-09-08 10:07:25 +00:00
|
|
|
}
|
2005-09-01 15:20:15 +00:00
|
|
|
}
|
2004-09-08 10:07:25 +00:00
|
|
|
if ($this->subpage=='finish') {
|
|
|
|
if ($post['createagain']) {
|
|
|
|
// Reset objects
|
|
|
|
$modules = array_keys($this->module);
|
2004-10-10 11:30:20 +00:00
|
|
|
foreach ($modules as $module) unset($this->module[$module]);
|
2004-09-08 10:07:25 +00:00
|
|
|
// Reset accountContainer
|
|
|
|
$this->dn = '';
|
|
|
|
$this->dn_orig = '';
|
|
|
|
$this->attributes = array();
|
|
|
|
$this->order = array();
|
|
|
|
$this->current_page = 0;
|
|
|
|
$this->subpage = '';
|
|
|
|
// Add all required objects etc.
|
|
|
|
$this->new_account();
|
|
|
|
$result = 0;
|
2005-09-01 15:20:15 +00:00
|
|
|
}
|
2004-09-08 10:07:25 +00:00
|
|
|
if ($post['backmain']) {
|
2006-01-06 10:47:43 +00:00
|
|
|
// Return to account list
|
|
|
|
unset($_SESSION[$this->base]);
|
|
|
|
metaRefresh("../lists/list.php?type=" . $this->type);
|
2004-09-08 10:07:25 +00:00
|
|
|
exit;
|
2005-09-01 15:20:15 +00:00
|
|
|
}
|
2004-09-08 10:07:25 +00:00
|
|
|
if ($post['outputpdf']) {
|
|
|
|
// Create / display PDf-file
|
2005-07-13 17:26:28 +00:00
|
|
|
createModulePDF(array($_SESSION[$this->base]), $post['pdfStructure']);
|
2004-09-08 10:07:25 +00:00
|
|
|
exit;
|
|
|
|
}
|
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2005-09-01 15:20:15 +00:00
|
|
|
else $result = call_user_func(array(&$this->module[$this->order[$this->current_page]], 'process_'.$this->subpage), $post);
|
|
|
|
}
|
2005-05-07 14:32:18 +00:00
|
|
|
// change to next page
|
|
|
|
$errorsOccured = false;
|
|
|
|
if (is_array($result)) { // messages were returned, check for errors
|
|
|
|
$errorKeys = array_keys($result);
|
|
|
|
for ($i = 0; $i < sizeof($errorKeys); $i++) {
|
|
|
|
for ($m = 0; $m < sizeof($result[$errorKeys[$i]]); $m++) {
|
|
|
|
if (($result[$errorKeys[$i]][$m][0] == 'ERROR') || ($result[$errorKeys[$i]][$m][0] == 'WARN')) {
|
|
|
|
$errorsOccured = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-09-01 15:20:15 +00:00
|
|
|
if (!$errorsOccured) {
|
2005-09-07 12:58:34 +00:00
|
|
|
// go to subpage of current module
|
2005-09-01 15:20:15 +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];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-09-07 12:58:34 +00:00
|
|
|
// change module page if requested
|
2004-09-08 10:07:25 +00:00
|
|
|
if ($post['form_main_main']) {
|
|
|
|
$this->current_page = 0;
|
|
|
|
$this->subpage='attributes';
|
2005-05-07 14:32:18 +00:00
|
|
|
}
|
2005-09-07 12:58:34 +00:00
|
|
|
else {
|
|
|
|
for ($i=1; $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()));
|
|
|
|
}
|
2005-08-02 19:06:29 +00:00
|
|
|
}
|
2005-05-07 14:32:18 +00:00
|
|
|
}
|
2005-09-07 12:58:34 +00:00
|
|
|
}
|
2005-05-07 14:32:18 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// Write HTML-Code
|
2004-09-28 15:41:16 +00:00
|
|
|
echo $_SESSION['header'];
|
2004-02-07 18:34:26 +00:00
|
|
|
echo "<title>";
|
|
|
|
if ($this->dn_orig!='') echo _("Modify Account");
|
|
|
|
else echo _("Create new Account");
|
|
|
|
echo "</title>\n";
|
|
|
|
echo "<link rel=\"stylesheet\" type=\"text/css\" href=\"../../style/layout.css\">\n";
|
2006-01-01 16:30:05 +00:00
|
|
|
echo "<link rel=\"stylesheet\" type=\"text/css\" href=\"../../style/type_" . $this->type . ".css\">\n";
|
2004-02-07 18:34:26 +00:00
|
|
|
echo "</head><body>\n";
|
2005-12-05 14:27:47 +00:00
|
|
|
echo "<form enctype=\"multipart/form-data\" action=\"edit.php\" method=\"post\">\n";
|
2004-10-12 13:34:00 +00:00
|
|
|
// Display error-messages
|
2005-05-10 16:51:32 +00:00
|
|
|
if (is_array($result)) {
|
|
|
|
foreach ($result as $result2) {
|
|
|
|
if (is_array($result2)) {
|
2004-02-07 18:34:26 +00:00
|
|
|
for ($i=0; $i<sizeof($result2); $i++) StatusMessage($result2[$i][0], $result2[$i][1], $result2[$i][2]);
|
2005-05-10 16:51:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (isset($stopProcessing) && ($stopProcessing == true)) {
|
|
|
|
echo "</body>\n";
|
|
|
|
echo "</html>\n";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2005-05-07 14:32:18 +00:00
|
|
|
if ($this->current_page==0) {
|
|
|
|
if ($this->subpage=='attributes') {
|
|
|
|
$modules = array_keys($this->module);
|
|
|
|
$disabled = false;
|
|
|
|
$incompleteModules = array();
|
|
|
|
foreach ($modules as $module) {
|
|
|
|
if (!$this->module[$module]->module_complete()) {
|
|
|
|
$disabled = true;
|
|
|
|
$incompleteModules[] = $this->module[$module]->get_alias();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sizeof($incompleteModules) > 0) {
|
|
|
|
StatusMessage('INFO', _('Some required information is missing'),
|
|
|
|
sprintf(_('Please set up all required attributes on page: %s'), implode(", ", $incompleteModules)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// Create left module-menu
|
2005-09-12 15:37:23 +00:00
|
|
|
echo "<table border=0 width=\"100%\">\n<tr valign=\"top\"><td width=\"15%\">";
|
2004-09-08 10:07:25 +00:00
|
|
|
|
2005-09-12 15:37:23 +00:00
|
|
|
echo "<fieldset class=\"".$this->type."edit\"><legend><b>";
|
2004-02-07 18:34:26 +00:00
|
|
|
echo _('Please select page:');
|
2006-01-01 16:30:05 +00:00
|
|
|
echo "</b></legend><center>\n";
|
2005-08-24 17:53:03 +00:00
|
|
|
// calculate button width
|
|
|
|
$buttonWidth = round(0.8 * strlen(utf8_decode(_("Reset changes"))));
|
|
|
|
for ($b = 0; $b < sizeof($this->order); $b++) {
|
|
|
|
$tempWidth = round(0.8 * strlen(utf8_decode($this->order[$b])));
|
|
|
|
if ($buttonWidth < $tempWidth) $buttonWidth = $tempWidth;
|
|
|
|
}
|
2004-09-15 19:52:29 +00:00
|
|
|
$x=0;
|
2005-08-24 18:08:23 +00:00
|
|
|
// print "main" button
|
|
|
|
echo "<input style=\"width:" . $buttonWidth ."em;margin:2px;\" name=\"form_main_main\" type=\"submit\" value=\"";
|
2004-09-28 15:41:16 +00:00
|
|
|
echo _('Main');
|
2005-05-10 16:51:32 +00:00
|
|
|
echo "\" tabindex=$x";
|
|
|
|
if ($this->subpage == 'finish') echo " disabled";
|
|
|
|
echo ">\n<br>";
|
2004-09-28 15:41:16 +00:00
|
|
|
$x++;
|
2004-02-07 18:34:26 +00:00
|
|
|
// Loop for module
|
2004-08-11 11:08:56 +00:00
|
|
|
// $x is used to count up tabindex
|
2004-09-08 10:07:25 +00:00
|
|
|
for ($i=1; $i<count($this->order); $i++ ) {
|
2005-08-26 08:53:16 +00:00
|
|
|
$buttonStatus = $this->module[$this->order[$i]]->getButtonStatus();
|
|
|
|
// skip hidden buttons
|
|
|
|
if ($buttonStatus == 'hidden') continue;
|
2004-09-28 15:41:16 +00:00
|
|
|
// print normal button
|
2005-08-24 18:08:23 +00:00
|
|
|
echo "<input style=\"width:" . $buttonWidth ."em;margin:2px;\" name=\"form_main_".$this->order[$i]."\" type=\"submit\" value=\"";
|
2004-09-28 15:41:16 +00:00
|
|
|
echo $this->module[$this->order[$i]]->get_alias();
|
2005-05-10 16:51:32 +00:00
|
|
|
echo "\" tabindex=$x";
|
2005-08-26 08:53:16 +00:00
|
|
|
if (($buttonStatus == 'disabled') || $this->subpage == 'finish') echo " disabled";
|
2005-05-10 16:51:32 +00:00
|
|
|
echo ">\n<br>";
|
2004-09-28 15:41:16 +00:00
|
|
|
$x++;
|
2005-08-26 08:53:16 +00:00
|
|
|
}
|
2005-05-10 16:51:32 +00:00
|
|
|
if ($this->dn_orig!='') {
|
2005-08-24 18:08:23 +00:00
|
|
|
echo "<br><input style=\"width:" . $buttonWidth ."em;margin:2px;\" name=\"form_main_reset\" type=\"submit\" value=\"" . _('Reset changes') . "\"";
|
2005-05-10 16:51:32 +00:00
|
|
|
if ($this->subpage == 'finish') echo " disabled";
|
|
|
|
echo "><br>\n";
|
|
|
|
}
|
2006-01-01 16:30:05 +00:00
|
|
|
echo "</center></fieldset>\n";
|
2005-09-12 15:37:23 +00:00
|
|
|
echo "</td>\n<td>";
|
2004-09-08 10:07:25 +00:00
|
|
|
if ($this->current_page==0) {
|
2005-09-12 15:37:23 +00:00
|
|
|
echo "<fieldset class=\"".$this->type."edit\"><legend><b>";
|
2004-09-08 10:07:25 +00:00
|
|
|
echo _('Main');
|
2004-02-07 18:34:26 +00:00
|
|
|
echo "</b></legend>\n";
|
2004-09-08 10:07:25 +00:00
|
|
|
}
|
|
|
|
else {
|
2005-09-12 15:37:23 +00:00
|
|
|
echo "<fieldset class=\"".$this->type."edit\"><legend><b>";
|
2005-08-02 09:48:55 +00:00
|
|
|
echo $this->module[$this->order[$this->current_page]]->get_alias();
|
2004-09-08 10:07:25 +00:00
|
|
|
echo "</b></legend>\n";
|
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// display html-code from mdule
|
2005-05-07 14:32:18 +00:00
|
|
|
$return = array();
|
2005-05-10 16:51:32 +00:00
|
|
|
if ($this->current_page == 0) {
|
|
|
|
if ($this->subpage == 'finish') {
|
2004-09-08 10:07:25 +00:00
|
|
|
// Show success message
|
2004-11-06 13:05:34 +00:00
|
|
|
if ($this->dn_orig == '') {
|
|
|
|
$text = _("Account was created successfully.");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$text = _("Account was modified successfully.");
|
|
|
|
}
|
2005-05-10 16:51:32 +00:00
|
|
|
$return[] = array(
|
|
|
|
0 => array('kind' => 'message', 'type' => 'INFO', 'headline' => _('LDAP operation successful.'), 'text' => $text,
|
|
|
|
'td' => array('colspan' => 3)));
|
|
|
|
$return[] = array(
|
|
|
|
0 => array('kind' => 'text', 'text' => '', 'td' => array('colspan' => 3)));
|
|
|
|
$return[] = array(
|
|
|
|
0 => array('kind' => 'input', 'type' => 'submit', 'name' => 'createagain', 'value' => _('Create another account')),
|
2005-07-13 17:26:28 +00:00
|
|
|
1 => array('kind' => 'input', 'type' => 'submit', 'name' => 'backmain', 'value' => _('Back to account list')));
|
2005-09-12 15:37:23 +00:00
|
|
|
$return[] = array(0 => array('kind' => 'text', 'text' => ' ')); // empty line
|
|
|
|
$return[] = array(0 => array('kind' => 'text', 'text' => ' ')); // empty line
|
2005-08-02 09:48:55 +00:00
|
|
|
$pdfStructures = getPDFStructureDefinitions($this->type);
|
2005-07-13 17:26:28 +00:00
|
|
|
$return[] = array(
|
|
|
|
0 => array('kind' => 'fieldset', 'legend' => '<b>PDF</b>', 'td' => array('colspan' => 2), 'value' => array(array(
|
|
|
|
0 => array('kind' => 'select', 'name' => 'pdfStructure', 'options' => $pdfStructures),
|
2005-09-12 15:37:23 +00:00
|
|
|
1 => array('kind' => 'input', 'type' => 'submit', 'name' => 'outputpdf', 'value' => _('Create PDF file')),
|
|
|
|
2 => array('kind' => 'help', 'value' => '403'))
|
2005-07-13 17:26:28 +00:00
|
|
|
)));
|
2005-05-10 16:51:32 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// loop through all suffixes
|
|
|
|
$rootsuffix = $_SESSION['config']->get_Suffix($this->type);
|
|
|
|
foreach ($_SESSION['ldap']->search_units($rootsuffix) as $suffix) {
|
|
|
|
if ($this->dn == $suffix) $options_selected = $suffix;
|
|
|
|
$suffixes[] = $suffix;
|
|
|
|
}
|
|
|
|
$return[] = array(
|
|
|
|
0 => array('kind' => 'text', 'text' => _('Suffix')),
|
2005-08-13 11:31:26 +00:00
|
|
|
1 => array('kind' => 'select', 'name' => 'suffix', 'options' => $suffixes, 'options_selected' => array($options_selected), 'noSorting' => true),
|
2005-09-12 15:37:23 +00:00
|
|
|
2 => array ('kind' => 'help', 'value' => '361'));
|
2005-05-10 16:51:32 +00:00
|
|
|
// RDN selection
|
|
|
|
$rdnlist = getRDNAttributes($this->type);
|
|
|
|
$rdnSelected = array();
|
|
|
|
if ($this->rdn != '') {
|
|
|
|
$rdnSelected[] = $this->rdn;
|
2004-09-08 10:07:25 +00:00
|
|
|
}
|
2005-05-10 16:51:32 +00:00
|
|
|
else {
|
|
|
|
$rdnSelected[] = $rdnlist[0];
|
|
|
|
}
|
|
|
|
$return[] = array(
|
|
|
|
0 => array('kind' => 'text', 'text' => _('RDN identifier')),
|
2005-08-13 11:31:26 +00:00
|
|
|
1 => array('kind' => 'select', 'name' => 'rdn', 'options' => $rdnlist, 'options_selected' => $rdnSelected, 'noSorting' => true),
|
2005-05-10 16:51:32 +00:00
|
|
|
2 => array ('kind' => 'help', 'value' => '301'));
|
|
|
|
|
|
|
|
// Get list of profiles
|
|
|
|
$profilelist = getAccountProfiles($this->type);
|
|
|
|
if (count($profilelist)!=0) {
|
|
|
|
$return[] = array(
|
|
|
|
0 => array('kind' => 'text', 'text' => _("Load profile")),
|
|
|
|
1 => array('kind' => 'table', 'value' => array(0 => array(
|
|
|
|
0 => array('kind' => 'select', 'name' => 'selectLoadProfile', 'options' => $profilelist),
|
|
|
|
1 => array('kind' => 'input', 'type' => 'submit', 'name' => 'loadProfile', 'value' => _('Load profile'))
|
2005-09-12 15:37:23 +00:00
|
|
|
))),
|
|
|
|
2 => array('kind' => 'help', 'value' => '401')
|
2005-05-10 16:51:32 +00:00
|
|
|
);
|
|
|
|
}
|
2005-09-12 15:37:23 +00:00
|
|
|
$return[] = array(0 => array('kind' => 'text', 'text' => ' ')); // empty line
|
2005-05-10 16:51:32 +00:00
|
|
|
if ($this->dn_orig!='') $text = _('Modify Account');
|
|
|
|
else $text = _('Create Account');
|
|
|
|
$return[] = array ( 0 => array ( 'kind' => 'text', 'text' => $text ),
|
|
|
|
1 => array ( 'kind' => 'input', 'type' => 'submit', 'name' => 'create', 'value' => $text, 'disabled' => $disabled),
|
2005-09-12 15:37:23 +00:00
|
|
|
2 => array ('kind' => 'help', 'value' => '402'));
|
2005-05-10 16:51:32 +00:00
|
|
|
}
|
2004-10-17 09:33:24 +00:00
|
|
|
}
|
2005-02-16 21:00:19 +00:00
|
|
|
else $return = call_user_func(array($this->module[$this->order[$this->current_page]], 'display_html_'.$this->subpage), $post);
|
|
|
|
$y = 5000;
|
|
|
|
$z = 10000;
|
2005-03-29 16:10:30 +00:00
|
|
|
parseHtml($this->order[$this->current_page], $return, array(), false, $y, $z, $this->type);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Display rest of html-page
|
2005-10-20 10:40:18 +00:00
|
|
|
echo "</fieldset>\n";
|
|
|
|
if ($this->current_page != "main") echo "<br>*" . _('required');
|
2004-02-07 18:34:26 +00:00
|
|
|
echo "</td></tr></table>\n";
|
|
|
|
echo "</form>\n";
|
|
|
|
echo "</body>\n";
|
|
|
|
echo "</html>\n";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-21 11:22:59 +00:00
|
|
|
/**
|
|
|
|
* Add attributes to variable. Syntax is array( attribute = array ( objectClass1 => MUST|MAX, objectClass2 => MUST|MAY ), ... )
|
|
|
|
* @todo document this function
|
2004-02-07 18:34:26 +00:00
|
|
|
*/
|
|
|
|
function add_attributes($objectClass) {
|
|
|
|
// loop through every existing objectlass and select current objectClass
|
|
|
|
$line=-1;
|
2004-09-08 19:30:18 +00:00
|
|
|
for ($i=0; $i<count($_SESSION['ldap']->objectClasses) || $i==-1; $i++) {
|
2004-09-14 11:53:33 +00:00
|
|
|
if (strpos(strtolower($_SESSION['ldap']->objectClasses[$i]), strtolower("NAME '$objectClass'"))) $line = $i;
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
// Return error if objectClass isn't found
|
2004-11-07 12:56:55 +00:00
|
|
|
if ($line==-1) trigger_error (sprintf(_("ObjectClass %s required but not defined in LDAP."), $objectClass), E_USER_WARNING);
|
2004-02-07 18:34:26 +00:00
|
|
|
// create array with must-attributes
|
|
|
|
// Get startposition in string
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')+6);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
|
|
|
$must = explode(" $ ", $string);
|
|
|
|
// Ad must
|
|
|
|
foreach ($must as $attribute) {
|
|
|
|
if (!isset($this->attributes[$attribute])) $this->attributes[$attribute][$objectClass] = 'MUST';
|
|
|
|
else $this->attributes[$attribute][$objectClass] = 'MUST';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// create array with may-attributes
|
|
|
|
// Get startposition in string
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')+5);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
|
|
|
$may = explode(" $ ", $string);
|
|
|
|
// Ad may
|
|
|
|
foreach ($may as $attribute) {
|
|
|
|
if (!isset($this->attributes[$attribute])) $this->attributes[$attribute][$objectClass] = 'MAY';
|
|
|
|
else $this->attributes[$attribute][$objectClass] = 'MAY';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Get attributes of subclasses
|
2004-09-08 19:30:18 +00:00
|
|
|
while (strpos($_SESSION['ldap']->objectClasses[$line], "SUP ")) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'SUP ')+4);
|
2004-02-07 18:34:26 +00:00
|
|
|
$subclass = substr($string_withtail, 0, strpos($string_withtail, ' '));
|
|
|
|
// Add account type to object
|
2004-09-08 19:30:18 +00:00
|
|
|
for ($i=0; $i<count($_SESSION['ldap']->objectClasses) || $i==-1; $i++) {
|
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$i], "NAME '$subclass'")) $line = $i;
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
// Return error if objectClass isn't found
|
2004-11-07 12:56:55 +00:00
|
|
|
if ($line==-1) trigger_error (sprintf(_("ObjectClass %s required but not defined in LDAP."), $objectClass), E_USER_WARNING);
|
2004-02-07 18:34:26 +00:00
|
|
|
// create array with must-attributes
|
|
|
|
// Get startposition in string
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')+6);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
|
|
|
$must = explode(" $ ", $string);
|
|
|
|
// Ad must
|
|
|
|
foreach ($must as $attribute) {
|
|
|
|
if (!isset($this->attributes[$attribute])) $this->attributes[$attribute][$objectClass] = 'MUST';
|
|
|
|
else $this->attributes[$attribute][$objectClass] = 'MUST';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// create array with may-attributes
|
|
|
|
// Get startposition in string
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')+5);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
|
|
|
$may = explode(" $ ", $string);
|
|
|
|
// Ad may
|
|
|
|
foreach ($may as $attribute) {
|
|
|
|
if (!isset($this->attributes[$attribute])) $this->attributes[$attribute][$objectClass] = 'MAY';
|
|
|
|
else $this->attributes[$attribute][$objectClass] = 'MAY';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-07-21 11:22:59 +00:00
|
|
|
/**
|
|
|
|
* This function returns all LDAP attributes which are used by the given object class.
|
|
|
|
* LDAP attributs which are already in use by another object class are passed as reference.
|
|
|
|
* <br>Therefore this function must be called as reference: $result =& ..get_module_attributes
|
2004-09-14 11:53:33 +00:00
|
|
|
*
|
2005-07-21 11:22:59 +00:00
|
|
|
* @param string $objectClass object class name
|
|
|
|
* @param boolean $original If original is true references will be set to original attributes. This are the original attributes
|
|
|
|
* when an LDAP entry is loaded.
|
|
|
|
* @return array list of attributes
|
2004-02-07 18:34:26 +00:00
|
|
|
*/
|
2004-09-14 11:53:33 +00:00
|
|
|
function get_module_attributes($objectClass, $original=false) {
|
2004-02-07 18:34:26 +00:00
|
|
|
// Add account type to object
|
|
|
|
$line=-1;
|
2004-09-08 19:30:18 +00:00
|
|
|
for ($i=0; $i<count($_SESSION['ldap']->objectClasses) || $i==-1; $i++) {
|
2004-09-14 11:53:33 +00:00
|
|
|
if (strpos(strtolower($_SESSION['ldap']->objectClasses[$i]), strtolower("NAME '$objectClass'"))) $line = $i;
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2004-09-15 19:52:29 +00:00
|
|
|
// Return empty array if no objectClass wasn't found
|
|
|
|
if ($line==-1) return array();
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')+6);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
2004-12-28 12:06:11 +00:00
|
|
|
// Add must
|
2004-02-07 18:34:26 +00:00
|
|
|
foreach (explode(" $ ", $string) as $attribute) {
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$attribute] = array();
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2004-12-28 12:06:11 +00:00
|
|
|
}
|
|
|
|
elseif (strpos($_SESSION['ldap']->objectClasses[$line], 'MUST ')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MUST ')+5);
|
|
|
|
// Now we have a string with the must-attribute
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ' '));
|
|
|
|
$string = trim($string);
|
|
|
|
// Add must
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$string] = array();
|
2004-12-28 12:06:11 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// create array with may-attributes
|
|
|
|
// Get startposition in string
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')+5);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
2004-12-28 12:06:11 +00:00
|
|
|
// Add may
|
2004-02-07 18:34:26 +00:00
|
|
|
foreach (explode(" $ ", $string) as $attribute) {
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$attribute] = array();
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2004-12-28 12:06:11 +00:00
|
|
|
}
|
|
|
|
elseif (strpos($_SESSION['ldap']->objectClasses[$line], 'MAY ')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MAY ')+4);
|
|
|
|
// Now we have a string with the may-attribute
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ' '));
|
|
|
|
$string = trim($string);
|
|
|
|
// Add must
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$string] = array();
|
2004-12-28 12:06:11 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// Get attributes of subclasses
|
2004-09-08 19:30:18 +00:00
|
|
|
while (strpos($_SESSION['ldap']->objectClasses[$line], "SUP ")) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'SUP ')+4);
|
2004-02-07 18:34:26 +00:00
|
|
|
$subclass = substr($string_withtail, 0, strpos($string_withtail, ' '));
|
|
|
|
// Add account type to object
|
2004-09-08 19:30:18 +00:00
|
|
|
for ($i=0; $i<count($_SESSION['ldap']->objectClasses) || $i==-1; $i++) {
|
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$i], "NAME '$subclass'")) $line = $i;
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
// Return error if objectClass isn't found
|
2004-11-06 13:05:34 +00:00
|
|
|
if ($line==-1) trigger_error (sprintf(_("ObjectClass %s required but not defined in LDAP."), $subclass), E_USER_WARNING);
|
2004-02-07 18:34:26 +00:00
|
|
|
// create array with must-attributes
|
|
|
|
// Get startposition in string
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MUST (')+6);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
2004-12-28 12:06:11 +00:00
|
|
|
// Add must
|
2004-02-07 18:34:26 +00:00
|
|
|
foreach (explode(" $ ", $string) as $attribute) {
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$attribute] = array();
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2004-12-28 12:06:11 +00:00
|
|
|
}
|
|
|
|
elseif (strpos($_SESSION['ldap']->objectClasses[$line], 'MUST ')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MUST ')+5);
|
|
|
|
// Now we have a string with the must-attribute
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ' '));
|
|
|
|
$string = trim($string);
|
|
|
|
// Add must
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$string] = array();
|
2004-12-28 12:06:11 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// create array with may-attributes
|
|
|
|
// Get startposition in string
|
2004-09-08 19:30:18 +00:00
|
|
|
if (strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MAY (')+5);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Now we have a string with all must-attributes
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ')'));
|
|
|
|
$string = trim($string);
|
2004-12-28 12:06:11 +00:00
|
|
|
// Add may
|
2004-02-07 18:34:26 +00:00
|
|
|
foreach (explode(" $ ", $string) as $attribute) {
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$attribute] = array();
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
2004-12-28 12:06:11 +00:00
|
|
|
elseif (strpos($_SESSION['ldap']->objectClasses[$line], 'MAY ')) {
|
|
|
|
$string_withtail = substr($_SESSION['ldap']->objectClasses[$line], strpos($_SESSION['ldap']->objectClasses[$line], 'MAY ')+4);
|
|
|
|
// Now we have a string with the may-attribute
|
|
|
|
$string = substr($string_withtail, 0, strpos($string_withtail, ' '));
|
|
|
|
$string = trim($string);
|
|
|
|
// Add must
|
2006-01-01 16:30:05 +00:00
|
|
|
$return[$string] = array();
|
2004-12-28 12:06:11 +00:00
|
|
|
}
|
|
|
|
}
|
2004-09-14 11:53:33 +00:00
|
|
|
|
2004-09-15 19:52:29 +00:00
|
|
|
// make references with attibutes which are used by more than one module
|
2004-09-14 11:53:33 +00:00
|
|
|
$newattributes = array_keys($return);
|
|
|
|
$module = array_keys($this->module);
|
|
|
|
if (!$original) {
|
|
|
|
// Only add attributes when original is false. We don't want to add them twice
|
|
|
|
$this->add_attributes($objectClass);
|
|
|
|
for ($i=0; $i<count($module); $i++) {
|
|
|
|
if ($module[$i]!=$objectClass)
|
|
|
|
foreach ($newattributes as $attribute)
|
2004-09-15 19:52:29 +00:00
|
|
|
if (isset($this->module[$module[$i]]->attributes[$attribute]) && ($attribute!='objectClass'))
|
2004-09-14 11:53:33 +00:00
|
|
|
$return[$attribute] =& $this->module[$module[$i]]->attributes[$attribute];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
for ($i=0; $i<count($module); $i++) {
|
|
|
|
if ($module[$i]!=$objectClass)
|
|
|
|
foreach ($newattributes as $attribute)
|
2004-09-15 19:52:29 +00:00
|
|
|
if (isset($this->module[$module[$i]]->orig[$attribute]) && ($attribute!='objectClass'))
|
2004-09-14 11:53:33 +00:00
|
|
|
$return[$attribute] =& $this->module[$module[$i]]->orig[$attribute];
|
|
|
|
}
|
|
|
|
}
|
2004-09-15 19:52:29 +00:00
|
|
|
$return['objectClass'] = array();
|
2004-09-14 13:09:13 +00:00
|
|
|
return $return;
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
2005-07-21 11:22:59 +00:00
|
|
|
/**
|
|
|
|
* This function checks which LDAP attributes have changed while the account was edited.
|
|
|
|
*
|
|
|
|
* @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) {
|
|
|
|
// Get list of all "easy" attributes
|
|
|
|
$attr_names = array_keys($attributes);
|
|
|
|
// Get attributes which should be added
|
|
|
|
for ($i=0; $i<count($attr_names); $i++) {
|
|
|
|
for ($j=0; $j<count($orig[$attr_names[$i]]); $j++) {
|
|
|
|
if (is_array($attributes[$attr_names[$i]])) {
|
|
|
|
if (!in_array($orig[$attr_names[$i]][$j], $attributes[$attr_names[$i]]))
|
2004-10-01 12:13:16 +00:00
|
|
|
if (($orig[$attr_names[$i]][$j]!='') && ($attr_names[$i]!='objectClass')) $torem[$attr_names[$i]][] = $orig[$attr_names[$i]][$j];
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2004-10-01 12:13:16 +00:00
|
|
|
else if (($orig[$attr_names[$i]][$j]!='') && ($attr_names[$i]!='objectClass')) $torem[$attr_names[$i]][] = $orig[$attr_names[$i]][$j];
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
for ($j=0; $j<count($attributes[$attr_names[$i]]); $j++) {
|
|
|
|
if (is_array($orig[$attr_names[$i]])) {
|
|
|
|
if (!in_array($attributes[$attr_names[$i]][$j], $orig[$attr_names[$i]]))
|
2004-10-01 12:13:16 +00:00
|
|
|
if ($attributes[$attr_names[$i]][$j]!='') $toadd[$attr_names[$i]][] = $attributes[$attr_names[$i]][$j];
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2004-10-01 12:13:16 +00:00
|
|
|
else if ($attributes[$attr_names[$i]][$j]!='') $toadd[$attr_names[$i]][] = $attributes[$attr_names[$i]][$j];
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
for ($j=0; $j<count($attributes[$attr_names[$i]]); $j++) {
|
|
|
|
if (is_array($orig[$attr_names[$i]]) && is_array($attributes[$attr_names[$i]])) {
|
|
|
|
if (($attributes[$attr_names[$i]][$j]==$orig[$attr_names[$i]][$j]) && $attributes[$attr_names[$i]][$j]!='')
|
2004-10-01 12:13:16 +00:00
|
|
|
$notchanged[$attr_names[$i]][] = $attributes[$attr_names[$i]][$j];
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-09-15 19:52:29 +00:00
|
|
|
// create modify with add and remove
|
2004-02-07 18:34:26 +00:00
|
|
|
if (is_array($toadd)) {
|
|
|
|
$attributes2 = array_keys($toadd);
|
|
|
|
for ($i=0; $i<count($attributes2); $i++) {
|
2004-09-15 19:52:29 +00:00
|
|
|
if (isset($torem[$attributes2[$i]]))
|
|
|
|
/* found modify entry
|
|
|
|
* Some ldap attributes must be set exactly one time.
|
|
|
|
* Adding or removing such an attribute wont't work
|
|
|
|
* because it would conflict with an ldap schema.
|
|
|
|
* Therefore when an attribute has only one entry
|
|
|
|
* and is set in $toadd and $torem this will be merged
|
|
|
|
* to $tomodify
|
|
|
|
*/
|
|
|
|
if ((count($toadd[$attributes2[$i]]==0)) && (count($torem[$attributes2[$i]]==0))) {
|
|
|
|
// found attribute which should only modified
|
|
|
|
$tomodify[$attributes2[$i]] = $toadd[$attributes2[$i]];
|
|
|
|
unset($toadd[$attributes2[$i]]);
|
|
|
|
unset($torem[$attributes2[$i]]);
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (count($toadd)!=0) $return[$this->dn]['add'] = $toadd;
|
|
|
|
if (count($torem)!=0) $return[$this->dn]['remove'] = $torem;
|
|
|
|
if (count($tomodify)!=0) $return[$this->dn]['modify'] = $tomodify;
|
|
|
|
if (count($notchanged)!=0) $return[$this->dn]['notchanged'] = $notchanged;
|
|
|
|
return $return;
|
|
|
|
}
|
|
|
|
|
2005-07-21 11:22:59 +00:00
|
|
|
/**
|
|
|
|
* Loads an LDAP account with the given DN.
|
|
|
|
*
|
|
|
|
* @param string $dn the DN of the account
|
2004-02-07 18:34:26 +00:00
|
|
|
*/
|
|
|
|
function load_account($dn) {
|
2004-10-17 09:36:36 +00:00
|
|
|
$modules = $_SESSION['config']->get_AccountModules($this->type);
|
2004-02-07 18:34:26 +00:00
|
|
|
$search = substr($dn, 0, strpos($dn, ','));
|
2004-09-08 19:30:18 +00:00
|
|
|
$result = ldap_search($_SESSION['ldap']->server(), $dn, $search);
|
|
|
|
$entry = ldap_first_entry($_SESSION['ldap']->server(), $result);
|
2004-02-07 18:34:26 +00:00
|
|
|
$this->dn = substr($dn, strpos($dn, ',')+1);
|
|
|
|
$this->dn_orig = $dn;
|
2005-05-02 17:41:09 +00:00
|
|
|
// extract RDN
|
|
|
|
$this->rdn = split("=", substr($dn, 0, strpos($dn, ',')));
|
|
|
|
$this->rdn = $this->rdn[0];
|
2004-09-08 19:30:18 +00:00
|
|
|
$attr = ldap_get_attributes($_SESSION['ldap']->server(), $entry);
|
2005-05-02 17:41:09 +00:00
|
|
|
$attrNames = array_keys($attr);
|
|
|
|
// remove 'count' entries and numerical entries
|
|
|
|
for ($i = 0; $i < count($attr); $i++) {
|
|
|
|
if (isset($attr[$i])) unset($attr[$i]);
|
|
|
|
}
|
2005-07-05 14:33:46 +00:00
|
|
|
for ($i = 0; $i < sizeof($attrNames); $i++) unset($attr[$attrNames[$i]]['count']);
|
|
|
|
unset($attr['count']);
|
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;
|
|
|
|
}
|
|
|
|
}
|
2005-05-02 17:41:09 +00:00
|
|
|
// save original attributes
|
|
|
|
$this->attributes_orig = $attr;
|
2004-02-12 12:09:41 +00:00
|
|
|
|
2004-02-12 11:26:30 +00:00
|
|
|
foreach ($modules as $module) {
|
2004-06-08 18:54:37 +00:00
|
|
|
if (!isset($this->module[$module])) {
|
|
|
|
$this->module[$module] = new $module($this->type);
|
|
|
|
$this->module[$module]->init($this->base);
|
|
|
|
}
|
2004-02-12 11:26:30 +00:00
|
|
|
$this->module[$module]->load_attributes($attr);
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
2005-08-23 12:16:58 +00:00
|
|
|
// sort module buttons
|
|
|
|
$this->sortModules();
|
2004-02-07 18:34:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-29 15:20:48 +00:00
|
|
|
/**
|
|
|
|
* This function will prepare the object for a new account.
|
2004-02-07 18:34:26 +00:00
|
|
|
*/
|
|
|
|
function new_account() {
|
2005-04-29 15:20:48 +00:00
|
|
|
$this->isNewAccount = true;
|
2004-10-17 09:36:36 +00:00
|
|
|
$modules = $_SESSION['config']->get_AccountModules($this->type);
|
2004-06-08 18:54:37 +00:00
|
|
|
foreach ($modules as $module) {
|
|
|
|
$this->module[$module] = new $module($this->type);
|
|
|
|
$this->module[$module]->init($this->base);
|
|
|
|
}
|
2005-08-23 12:16:58 +00:00
|
|
|
// sort module buttons
|
|
|
|
$this->sortModules();
|
2005-04-16 10:58:18 +00:00
|
|
|
$profile = loadAccountProfile('default', $this->type);
|
|
|
|
// pass profile to each module
|
|
|
|
$modules = array_keys($this->module);
|
|
|
|
foreach ($modules as $module) $this->module[$module]->load_profile($profile);
|
2005-05-22 09:05:33 +00:00
|
|
|
if (isset($profile['ldap_rdn'][0])) {
|
2005-08-13 09:38:32 +00:00
|
|
|
if (in_array($profile['ldap_rdn'][0], getRDNAttributes($this->type))) {
|
|
|
|
$this->rdn = $profile['ldap_rdn'][0];
|
|
|
|
}
|
2005-05-22 09:05:33 +00:00
|
|
|
}
|
|
|
|
if (isset($profile['ldap_suffix'][0])) {
|
|
|
|
$this->dn = $profile['ldap_suffix'][0];
|
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-05-02 17:41:09 +00:00
|
|
|
/**
|
|
|
|
* This function will save an account to the LDAP database.
|
|
|
|
*
|
|
|
|
* @return array list of status messages if any errors occured
|
2004-02-07 18:34:26 +00:00
|
|
|
*/
|
|
|
|
function save_account() {
|
|
|
|
$module = array_keys ($this->module);
|
|
|
|
$attributes = array();
|
|
|
|
// load attributes
|
|
|
|
foreach ($module as $singlemodule) {
|
|
|
|
// load changes
|
|
|
|
$temp = $this->module[$singlemodule]->save_attributes();
|
2005-12-17 12:07:36 +00:00
|
|
|
if (!is_array($temp)) $temp = array();
|
2004-02-07 18:34:26 +00:00
|
|
|
// merge changes
|
|
|
|
$DNs = array_keys($temp);
|
|
|
|
// *** fixme don't include references
|
2005-07-06 13:35:54 +00:00
|
|
|
if (is_array($temp)) $attributes = array_merge_recursive($temp, $attributes);
|
2004-02-07 18:34:26 +00:00
|
|
|
for ($i=0; $i<count($DNs); $i++) {
|
|
|
|
$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_unique($attributes[$DNs[$i]][$ops[$j]][$attrs[$k]]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-10-24 17:23:23 +00:00
|
|
|
/* We have to some string checks now. Not every ldap attributes allow utf8
|
|
|
|
* strings. Therefore we do a syntax check here and change utf8 strings to ascci
|
|
|
|
* strings. Only "7bit" ascci is allowed
|
|
|
|
*/
|
|
|
|
// TODO how do we interact with the user and show him what has been changed
|
2004-02-07 18:34:26 +00:00
|
|
|
// Complete dn with uid or cn=
|
2005-05-02 17:41:09 +00:00
|
|
|
$search = $this->rdn;
|
2004-02-07 18:34:26 +00:00
|
|
|
$added = false;
|
|
|
|
foreach ($attributes as $DN) {
|
|
|
|
if (isset($DN['modify'][$search][0]) && !$added) {
|
|
|
|
$attributes[$search.'='.$DN['modify'][$search][0].','.$this->dn] = $attributes[$this->dn];
|
|
|
|
unset ($attributes[$this->dn]);
|
|
|
|
$this->dn = $search.'='.$DN['modify'][$search][0].','.$this->dn;
|
|
|
|
$added = true;
|
|
|
|
}
|
|
|
|
if (isset($DN['add'][$search][0]) && !$added) {
|
|
|
|
$attributes[$search.'='.$DN['add'][$search][0].','.$this->dn] = $attributes[$this->dn];
|
|
|
|
unset ($attributes[$this->dn]);
|
|
|
|
$this->dn = $search.'='.$DN['add'][$search][0].','.$this->dn;
|
|
|
|
$added = true;
|
|
|
|
}
|
|
|
|
if (isset($DN['notchanged'][$search][0]) && !$added) {
|
|
|
|
$attributes[$search.'='.$DN['notchanged'][$search][0].','.$this->dn] = $attributes[$this->dn];
|
|
|
|
unset ($attributes[$this->dn]);
|
|
|
|
$this->dn = $search.'='.$DN['notchanged'][$search][0].','.$this->dn;
|
|
|
|
$added = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Add old dn if dn hasn't changed
|
|
|
|
if (!$added) {
|
|
|
|
$attributes[$this->dn_orig] = $attributes[$this->dn];
|
|
|
|
unset ($attributes[$this->dn]);
|
|
|
|
$this->dn = $this->dn_orig;
|
|
|
|
}
|
|
|
|
// Set to true if an real error has happened
|
|
|
|
$stopprocessing = false;
|
|
|
|
// Add new DN
|
|
|
|
if (isset($attributes[$DNs[$i]]['errors'])) {
|
|
|
|
foreach ($attributes[$DNs[$i]]['errors'] as $singleerror) {
|
|
|
|
$errors[] = $singleerror;
|
2005-08-23 12:16:58 +00:00
|
|
|
if ($singleerror[0] == 'ERROR') $stopprocessing = true;
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!$stopprocessing) {
|
2005-11-22 15:44:49 +00:00
|
|
|
if (strtolower($this->dn) != strtolower($this->dn_orig)) {
|
2004-02-07 18:34:26 +00:00
|
|
|
// move existing DN
|
|
|
|
if ($this->dn_orig!='') {
|
|
|
|
// merge attributes together
|
2005-07-06 13:35:54 +00:00
|
|
|
$attr = array();
|
|
|
|
if (is_array($attributes[$this->dn]['add'])) $attr = array_merge_recursive($attr, $attributes[$this->dn]['add']);
|
|
|
|
if (is_array($attributes[$this->dn]['notchanged'])) $attr = array_merge_recursive($attr, $attributes[$this->dn]['notchanged']);
|
|
|
|
if (is_array($attributes[$this->dn]['modify'])) $attr = array_merge_recursive($attr, $attributes[$this->dn]['modify']);
|
2005-05-02 17:41:09 +00:00
|
|
|
// add attributes which are not controlled by modules from original account
|
|
|
|
$attrNames = array_keys($this->attributes_orig);
|
|
|
|
for ($i = 0; $i < sizeof($attrNames); $i++) {
|
|
|
|
if (!isset($attr[$attrNames[$i]])) $attr[$attrNames[$i]] = $this->attributes_orig[$attrNames[$i]];
|
|
|
|
}
|
2005-09-20 15:45:36 +00:00
|
|
|
// add missing object classes
|
|
|
|
for ($i = 0; $i < sizeof($this->attributes_orig['objectClass']); $i++) {
|
|
|
|
if (!in_array($this->attributes_orig['objectClass'][$i], $attr['objectClass'])) {
|
|
|
|
$attr['objectClass'][] = $this->attributes_orig['objectClass'][$i];
|
|
|
|
}
|
|
|
|
}
|
2004-09-08 19:30:18 +00:00
|
|
|
$success = ldap_add($_SESSION['ldap']->server(), $this->dn, $attr);
|
2004-02-07 18:34:26 +00:00
|
|
|
if ($success) {
|
2004-09-08 19:30:18 +00:00
|
|
|
$success = ldap_delete($_SESSION['ldap']->server(), $this->dn_orig);
|
2004-02-07 18:34:26 +00:00
|
|
|
if (!$success) {
|
2005-05-10 16:51:32 +00:00
|
|
|
$errors[] = array('ERROR', sprintf(_('Was unable to delete DN: %s.'), $this->dn_orig), ldap_error($_SESSION['ldap']->server()));
|
2004-02-07 18:34:26 +00:00
|
|
|
$stopprocessing = true;
|
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
if (!$success) {
|
2005-05-10 16:51:32 +00:00
|
|
|
$errors[] = array('ERROR', sprintf(_('Was unable to create DN: %s.'), $this->dn), ldap_error($_SESSION['ldap']->server()));
|
2004-02-07 18:34:26 +00:00
|
|
|
$stopprocessing = true;
|
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// create complete new dn
|
|
|
|
else {
|
2005-07-06 13:35:54 +00:00
|
|
|
$attr = array();
|
|
|
|
if (is_array($attributes[$this->dn]['add'])) $attr = array_merge_recursive($attr, $attributes[$this->dn]['add']);
|
|
|
|
if (is_array($attributes[$this->dn]['notchanged'])) $attr = array_merge_recursive($attr, $attributes[$this->dn]['notchanged']);
|
|
|
|
if (is_array($attributes[$this->dn]['modify'])) $attr = array_merge_recursive($attr, $attributes[$this->dn]['modify']);
|
2004-09-08 19:30:18 +00:00
|
|
|
$success = ldap_add($_SESSION['ldap']->server(), $this->dn, $attr);
|
2004-02-07 18:34:26 +00:00
|
|
|
if (!$success) {
|
2005-05-10 16:51:32 +00:00
|
|
|
$errors[] = array('ERROR', sprintf(_('Was unable to create DN: %s.'), $this->dn), ldap_error($_SESSION['ldap']->server()));
|
2004-02-07 18:34:26 +00:00
|
|
|
$stopprocessing = true;
|
|
|
|
}
|
2005-10-21 13:48:30 +00:00
|
|
|
// lamdaemon commands for the new account
|
|
|
|
if (!$stopprocessing) {
|
|
|
|
$DN = $attributes[$this->dn];
|
|
|
|
if (is_array($DN['lamdaemon']['command'])) $result = lamdaemon($DN['lamdaemon']['command']);
|
|
|
|
// Error somewhere in lamdaemon
|
|
|
|
if (is_array($result)) {
|
|
|
|
foreach ($result as $singleresult) {
|
|
|
|
if (is_array($singleresult)) {
|
|
|
|
if ($singleresult[0] == 'ERROR') $stopprocessing = true;
|
|
|
|
$temparray[0] = $singleresult[0];
|
|
|
|
$temparray[1] = _($singleresult[1]);
|
|
|
|
$temparray[2] = _($singleresult[2]);
|
|
|
|
$errors[] = $temparray;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
unset($attributes[$this->dn]);
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
$DNs = array_keys($attributes);
|
|
|
|
for ($i=0; $i<count($DNs); $i++) {
|
|
|
|
if (!$stopprocessing) {
|
|
|
|
// modify attributes
|
|
|
|
if (isset($attributes[$DNs[$i]]['modify']) && !$stopprocessing) {
|
2004-09-08 19:30:18 +00:00
|
|
|
$success = @ldap_mod_replace($_SESSION['ldap']->server(), $DNs[$i], $attributes[$DNs[$i]]['modify']);
|
2004-02-07 18:34:26 +00:00
|
|
|
if (!$success) {
|
2005-05-10 16:51:32 +00:00
|
|
|
$errors[] = array('ERROR', sprintf(_('Was unable to modify attribtues from DN: %s.'), $DNs[$i]), ldap_error($_SESSION['ldap']->server()));
|
2004-02-07 18:34:26 +00:00
|
|
|
$stopprocessing = true;
|
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
// add attributes
|
|
|
|
if (isset($attributes[$DNs[$i]]['add']) && !$stopprocessing) {
|
2004-09-08 19:30:18 +00:00
|
|
|
$success = @ldap_mod_add($_SESSION['ldap']->server(), $DNs[$i], $attributes[$DNs[$i]]['add']);
|
2004-02-07 18:34:26 +00:00
|
|
|
if (!$success) {
|
2005-05-10 16:51:32 +00:00
|
|
|
$errors[] = array('ERROR', sprintf(_('Was unable to add attribtues to DN: %s.'), $DNs[$i]), ldap_error($_SESSION['ldap']->server()));
|
2004-02-07 18:34:26 +00:00
|
|
|
$stopprocessing = true;
|
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
2005-12-05 14:27:47 +00:00
|
|
|
// remove attributes
|
2004-02-07 18:34:26 +00:00
|
|
|
if (isset($attributes[$DNs[$i]]['remove']) && !$stopprocessing) {
|
2004-09-08 19:30:18 +00:00
|
|
|
$success = @ldap_mod_del($_SESSION['ldap']->server(), $DNs[$i], $attributes[$DNs[$i]]['remove']);
|
2004-02-07 18:34:26 +00:00
|
|
|
if (!$success) {
|
2005-05-10 16:51:32 +00:00
|
|
|
$errors[] = array('ERROR', sprintf(_('Was unable to remove attribtues from DN: %s.'), $DNs[$i]), ldap_error($_SESSION['ldap']->server()));
|
2004-02-07 18:34:26 +00:00
|
|
|
$stopprocessing = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
|
|
|
|
if (!$stopprocessing) {
|
|
|
|
foreach ($attributes as $DN) {
|
2004-12-09 19:10:57 +00:00
|
|
|
if (is_array($DN['lamdaemon']['command'])) $result = lamdaemon($DN['lamdaemon']['command']);
|
2004-02-07 18:34:26 +00:00
|
|
|
// Error somewhere in lamdaemon
|
2005-10-15 09:33:05 +00:00
|
|
|
if (is_array($result)) {
|
2004-09-08 10:58:56 +00:00
|
|
|
foreach ($result as $singleresult) {
|
|
|
|
if (is_array($singleresult)) {
|
2005-08-23 12:16:58 +00:00
|
|
|
if ($singleresult[0] == 'ERROR') $stopprocessing = true;
|
2004-09-08 10:58:56 +00:00
|
|
|
$temparray[0] = $singleresult[0];
|
|
|
|
$temparray[1] = _($singleresult[1]);
|
|
|
|
$temparray[2] = _($singleresult[2]);
|
|
|
|
$errors[] = $temparray;
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
2005-10-15 09:33:05 +00:00
|
|
|
}
|
|
|
|
$_SESSION['cache']->refresh_cache(true);
|
2004-02-07 18:34:26 +00:00
|
|
|
if (count($errors)!=0) return $errors;
|
|
|
|
return 0;
|
2005-08-05 08:49:03 +00:00
|
|
|
}
|
2004-02-07 18:34:26 +00:00
|
|
|
|
2005-08-05 08:49:03 +00:00
|
|
|
/**
|
|
|
|
* Returns a list of possible PDF entries for this account.
|
|
|
|
*
|
|
|
|
* @return list of PDF entries (array(<name> => <PDF lines>))
|
|
|
|
*/
|
|
|
|
function get_pdfEntries() {
|
|
|
|
$return = array();
|
|
|
|
while(($current = current($this->module)) != null) {
|
2005-10-09 18:05:32 +00:00
|
|
|
$return = array_merge($return,$current->get_pdfEntries());
|
2005-08-05 08:49:03 +00:00
|
|
|
next($this->module);
|
2004-05-23 15:23:00 +00:00
|
|
|
}
|
2005-08-05 08:49:03 +00:00
|
|
|
$return = array_merge($return,array('main_dn' => array('<block><key>' . _('DN') . '</key><value>' . $this->dn . '</value></block>')));
|
|
|
|
return $return;
|
|
|
|
}
|
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();
|
|
|
|
for ($i = 0; $i < sizeof($modules); $i++) {
|
|
|
|
// insert waiting modules
|
|
|
|
for ($w = 0; $w < sizeof($depModules); $w++) {
|
|
|
|
$dependencies = $this->module[$depModules[$w]]->get_dependencies($this->type);
|
|
|
|
$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
|
|
|
|
$dependencies = $this->module[$modules[$i]]->get_dependencies($this->type);
|
|
|
|
if (is_array($dependencies['depends'])) {
|
|
|
|
$everything_found = true;
|
|
|
|
$dependencies = $dependencies['depends'];
|
|
|
|
for ($d = 0; $d < sizeof($dependencies); $d++) {
|
|
|
|
if (!in_array($dependencies[$d], $order)) {
|
|
|
|
$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) {
|
|
|
|
for ($i = 0; $i < sizeof($depModules); $i++) $order[] = $depModules[$i];
|
|
|
|
}
|
|
|
|
array_unshift($order, 'main');
|
|
|
|
$this->order = $order;
|
|
|
|
}
|
|
|
|
|
2005-08-05 08:49:03 +00:00
|
|
|
/**
|
|
|
|
* Encrypts sensitive data before storing in session.
|
|
|
|
*
|
|
|
|
* @return array list of attributes which are serialized
|
|
|
|
*/
|
|
|
|
function __sleep() {
|
|
|
|
// encrypt data
|
|
|
|
$this->attributes = $_SESSION['ldap']->encrypt(serialize($this->attributes));
|
|
|
|
$this->attributes_orig = $_SESSION['ldap']->encrypt(serialize($this->attributes_orig));
|
|
|
|
$this->module = $_SESSION['ldap']->encrypt(serialize($this->module));
|
|
|
|
// save all attributes
|
2005-09-04 12:49:26 +00:00
|
|
|
return array_keys(get_object_vars($this));
|
2005-08-05 08:49:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Decrypts sensitive data after accountContainer was loaded from session.
|
|
|
|
*/
|
|
|
|
function __wakeup() {
|
|
|
|
// decrypt data
|
|
|
|
$this->attributes = unserialize($_SESSION['ldap']->decrypt($this->attributes));
|
|
|
|
$this->attributes_orig = unserialize($_SESSION['ldap']->decrypt($this->attributes_orig));
|
|
|
|
$this->module = unserialize($_SESSION['ldap']->decrypt($this->module));
|
2004-02-07 18:34:26 +00:00
|
|
|
}
|
2005-08-05 08:49:03 +00:00
|
|
|
|
|
|
|
}
|
2004-09-08 10:07:25 +00:00
|
|
|
?>
|