Services/LDAP/classes/class.ilLDAPRoleGroupMapping.php

Go to the documentation of this file.

<?php
/*
        +-----------------------------------------------------------------------------+
        | ILIAS open source                                                           |
        +-----------------------------------------------------------------------------+
        | Copyright (c) 1998-2006 ILIAS open source, University of Cologne            |
        |                                                                             |
        | 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. |
        +-----------------------------------------------------------------------------+
*/

include_once('Services/LDAP/classes/class.ilLDAPServer.php');

class ilLDAPRoleGroupMapping
{
        private $log = null;
        private static $instance = null;
        private $servers = null;
        private $mappings = array();
        private $mapping_members = array();
        private $query = array();
        private $active_servers = false;
        
        private function __construct()
        {
                global $ilLog;
                
                $this->log = $ilLog;
                $this->initServers();
        }
        
        public static function _getInstance()
        {
                if(is_object(self::$instance))
                {
                        return self::$instance; 
                }
                return self::$instance = new ilLDAPRoleGroupMapping();
        }
        
        public function getInfoStrings($a_obj_id,$a_check_type = false)
        {
                if(!$this->active_servers)
                {
                        return false;
                }
                if($a_check_type)
                {
                        if(isset($this->mapping_info_strict[$a_obj_id]) and is_array($this->mapping_info_strict[$a_obj_id]))
                        {
                                return $this->mapping_info_strict[$a_obj_id];
                        }
                }
                else
                {
                        if(isset($this->mapping_info[$a_obj_id]) and is_array($this->mapping_info[$a_obj_id]))
                        {
                                return $this->mapping_info[$a_obj_id];
                        }
                        
                }
                return false;
        }
        
        
        public function assign($a_role_id,$a_usr_id)
        {
                // return if there nothing to do
                if(!$this->active_servers)
                {
                        return false;
                }
                
                if(!$this->isHandledRole($a_role_id))
                {
                        return false;
                }
                if(!$this->isHandledUser($a_usr_id))
                {
                        $this->log->write('LDAP assign: User ID: '.$a_usr_id.' has no LDAP account');
                        return false;
                }
                $this->log->write('LDAP assign: User ID: '.$a_usr_id.' Role Id: '.$a_role_id);
                $this->assignToGroup($a_role_id,$a_usr_id);

                return true;
        }
        
        public function deleteRole($a_role_id)
        {
                global $rbacreview;
                
                // return if there nothing to do
                if(!$this->active_servers)
                {
                        return false;
                }
                
                if(!$this->isHandledRole($a_role_id))
                {
                        return false;
                }
                
                foreach($rbacreview->assignedUsers($a_role_id) as $usr_id)
                {
                        $this->deassign($a_role_id,$usr_id);
                }
                return true;
        }
        
        
        public function deassign($a_role_id,$a_usr_id)
        {
                // return if there notzing to do
                if(!$this->active_servers)
                {
                        return false;
                }
                if(!$this->isHandledRole($a_role_id))
                {
                        return false;
                }
                if(!$this->isHandledUser($a_usr_id))
                {
                        return false;
                }
                $this->log->write('LDAP deassign: User ID: '.$a_usr_id.' Role Id: '.$a_role_id);
                $this->deassignFromGroup($a_role_id,$a_usr_id);
                
                return true;
        }
        
        public function deleteUser($a_usr_id)
        {
                foreach($this->mappings as $role_id => $data)
                {
                        $this->deassign($role_id,$a_usr_id);
                }
                return true;            
        }
        
        
        private function initServers()
        {
                $server_ids = ilLDAPServer::_getRoleSyncServerIds();
                
                if(!count($server_ids))
                {
                        return false;
                }
                
                // Init servers
                include_once('Services/LDAP/classes/class.ilLDAPRoleGroupMappingSettings.php');
                
                $this->active_servers = true;
                $this->mappings = array();
                foreach($server_ids as $server_id)
                {
                        $this->servers[$server_id]  = new ilLDAPServer($server_id);
                        $this->mappings = ilLDAPRoleGroupMappingSettings::_getAllActiveMappings();
                }
                $this->mapping_info = array();
                $this->mapping_info_strict = array();
                foreach($this->mappings as $mapping)
                {
                        foreach($mapping as $key => $data)
                        {
                                if(strlen($data['info']) and $data['object_id'])
                                {
                                        $this->mapping_info[$data['object_id']][] = $data['info'];
                                }
                                if(strlen($data['info']) && ($data['info_type'] == ilLDAPRoleGroupMappingSettings::MAPPING_INFO_ALL))
                                {
                                        $this->mapping_info_strict[$data['object_id']][] = $data['info'];
                                }
                        }
                }
                $this->users = ilObjUser::_getExternalAccountsByAuthMode('ldap',true);
                
                return true;
        }
        
        private function isHandledRole($a_role_id)
        {
                return array_key_exists($a_role_id,$this->mappings);
        }
        
        private function isHandledUser($a_usr_id)
        {
                return array_key_exists($a_usr_id,$this->users);
        }
        
        
        private function assignToGroup($a_role_id,$a_usr_id)
        {
                foreach($this->mappings[$a_role_id] as $data)
                {
                        try
                        {
                                if($data['isdn'])
                                {
                                        $external_account = $this->readDN($a_usr_id,$data['server_id']);
                                }
                                else
                                {
                                        $external_account = $this->users[$a_usr_id];
                                }
                                
                                // Forcing modAdd since Active directory is too slow and i cannot check if a user is member or not.
                                #if($this->isMember($external_account,$data))
                                #{
                                #       $this->log->write("LDAP assign: User already assigned to group '".$data['dn']."'");
                                #}
                                #else
                                {
                                        // Add user
                                        $query_obj = $this->getLDAPQueryInstance($data['server_id'],$data['url']);
                                        $query_obj->modAdd($data['dn'],array($data['member'] => $external_account));
                                        $this->log->write('LDAP assign: Assigned '.$external_account.' to group '.$data['dn']);         
                                }                               
                        }
                        catch(ilLDAPQueryException $exc)
                        {
                                $this->log->write($exc->getMessage());
                                // try next mapping
                                continue;
                        }                       
                }
        }
        
        private function deassignFromGroup($a_role_id,$a_usr_id)
        {
                foreach($this->mappings[$a_role_id] as $data)
                {
                        try
                        {
                                if($data['isdn'])
                                {
                                        $external_account = $this->readDN($a_usr_id,$data['server_id']);
                                }
                                else
                                {
                                        $external_account = $this->users[$a_usr_id];
                                }
                                
                                // Check for other role membership
                                if($role_id = $this->checkOtherMembership($a_usr_id,$a_role_id,$data))
                                {
                                        $this->log->write('LDAP deassign: User is still assigned to role "'.$role_id.'".');
                                        continue;
                                }
                                /*
                                if(!$this->isMember($external_account,$data))
                                {
                                        $this->log->write("LDAP deassign: User not assigned to group '".$data['dn']."'");
                                        continue;
                                }
                                */
                                // Deassign user
                                $query_obj = $this->getLDAPQueryInstance($data['server_id'],$data['url']);
                                $query_obj->modDelete($data['dn'],array($data['member'] => $external_account));
                                $this->log->write('LDAP deassign: Deassigned '.$external_account.' from group '.$data['dn']);
                                
                                // Delete from cache
                                if(is_array($this->mapping_members[$data['mapping_id']]))
                                {
                                        $key = array_search($external_account,$this->mapping_members[$data['mapping_id']]);
                                        if($key or $key === 0)
                                        {
                                                unset($this->mapping_members[$data['mapping_id']]);
                                        }
                                }
                                
                        }
                        catch(ilLDAPQueryException $exc)
                        {
                                $this->log->write($exc->getMessage());
                                // try next mapping
                                continue;
                        }                       
                }       
        }
        
        private function isMember($a_uid,$data)
        {
                if(!isset($this->mapping_members["$data[mapping_id]"]))
                {
                        // Read members
                        try
                        {
                                $server = $this->servers["$data[server_id]"];
                                $query_obj = $this->getLDAPQueryInstance($data['server_id'],$server->getUrl());

                                // query for members
                                $res = $query_obj->query($data['dn'],
                                        '(objectClass=*)',
                                        IL_LDAP_SCOPE_BASE,
                                        array($data['member']));
                                
                                $this->storeMembers($data['mapping_id'],$res->get());
                                unset($res);
                        }
                        catch(ilLDAPQueryException $exc)
                        {
                                throw $exc;
                        }
                }
                #var_dump("<pre>",$a_uid,$this->mapping_members,"</pre>");
                
                // Now check for membership in stored result
                if(in_array($a_uid,$this->mapping_members["$data[mapping_id]"]))
                {
                        return true;
                }
                return false;
        }
        
        private function checkOtherMembership($a_usr_id,$a_role_id,$a_data)
        {
                global $rbacreview,$ilObjDataCache;
                
                foreach($this->mappings as $role_id => $tmp_data)
                {
                        foreach($tmp_data as $data)
                        {
                                if($role_id == $a_role_id)
                                {
                                        continue;
                                }
                                if($data['server_id'] != $a_data['server_id'])
                                {
                                        continue;
                                }
                                if($data['dn'] != $a_data['dn'])
                                {
                                        continue;
                                }
                                if($rbacreview->isAssigned($a_usr_id,$role_id))
                                {
                                        return $ilObjDataCache->lookupTitle($role_id);
                                }
                        }
                }
                return false;
                
        }
        
        private function storeMembers($a_mapping_id,$a_data)
        {
                $this->mapping_members[$a_mapping_id] = array();
                foreach($a_data as $field => $value)
                {
                        if(strtolower($field) == 'dn')
                        {
                                continue;
                        }
                        
                        if(!is_array($value))
                        {
                                $this->mapping_members[$a_mapping_id][] = $value;
                                continue;
                        }
                        foreach($value as $external_account)
                        {
                                $this->mapping_members[$a_mapping_id][] = $external_account;
                        }
                }
                return true;
        }
        
        private function readDN($a_usr_id,$a_server_id)
        {
                if(isset($this->user_dns[$a_usr_id]))
                {
                        return $this->user_dns[$a_usr_id];
                }
                
                $external_account = $this->users[$a_usr_id];
                
                try
                {
                        $server = $this->servers[$a_server_id];
                        $query_obj = $this->getLDAPQueryInstance($a_server_id,$server->getUrl());
                                                
                        if($search_base = $server->getSearchBase())
                        {
                                $search_base .= ',';
                        }
                        $search_base .= $server->getBaseDN();
                        
                        $filter = sprintf('(&(%s=%s)%s)',
                                $server->getUserAttribute(),
                                $external_account,
                                $server->getFilter());
                        
                        $res = $query_obj->query($search_base,$filter,$server->getUserScope(),array('dn'));
                        
                        if(!$res->numRows())
                        {
                                include_once('Services/LDAP/classes/class.ilLDAPQueryException.php');
                                throw new ilLDAPQueryException(__METHOD__.' cannot find dn for user '.$external_account);
                        }
                        if($res->numRows() > 1)
                        {
                                include_once('Services/LDAP/classes/class.ilLDAPQueryException.php');
                                throw new ilLDAPQueryException(__METHOD__.' found multiple distinguished name for: '.$external_account);
                        }
                        
                        $data = $res->get();
                        return $this->user_dns[$a_usr_id] = $data['dn'];
                }
                catch(ilLDAPQueryException $exc)
                {
                        throw $exc;
                }
        }
        
        private function getLDAPQueryInstance($a_server_id,$a_url)
        {
                include_once 'Services/LDAP/classes/class.ilLDAPQuery.php';

                if(array_key_exists($a_server_id,$this->query) and 
                        array_key_exists($a_url,$this->query[$a_server_id]) and 
                        is_object($this->query[$a_server_id][$a_url]))
                {
                        return $this->query[$a_server_id][$a_url];
                }
                try
                {
                        $tmp_query = new ilLDAPQuery($this->servers[$a_server_id],$a_url);
                        $tmp_query->bind(IL_LDAP_BIND_ADMIN);
                }
                catch(ilLDAPQueryException $exc)
                {
                        throw $exc;
                }
                return $this->query[$a_server_id][$a_url] = $tmp_query;
        }
        
}


?>