Documentation TYPO3 par Ameos

Disponible dans d'autres versions de TYPO3 -> 3.7.0  3.8.1  4.0.0  4.0.1  4.1.0   <- Available in other TYPO3 versions

class.t3lib_userauthgroup.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2004 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project 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.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script 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.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
        // Need this for parsing User TSconfig
require_once (PATH_t3lib.'class.t3lib_tsparser.php');





















class t3lib_userAuthGroup extends t3lib_userAuth {
        var $usergroup_column = 'usergroup';            // Should be set to the usergroup-column (id-list) in the user-record
        var $usergroup_table = 'be_groups';                     // The name of the group-table

                // internal
        var $groupData = Array(                         // This array holds lists of eg. tables, fields and other values related to the permission-system. See fetchGroupData
                'filemounts' => Array()                 // Filemounts are loaded here
        );

        var $userGroups = Array();                      // This array will hold the groups that the user is a member of
        var $userGroupsUID = Array();           // This array holds the uid's of the groups in the listed order
        var $groupList ='';                                     // This is $this->userGroupsUID imploded to a comma list... Will correspond to the 'usergroup_cached_list'
        var $dataLists=array(                           // Used internally to accumulate data for the user-group. DONT USE THIS EXTERNALLY! Use $this->groupData instead
                'webmount_list'=>'',
                'filemount_list'=>'',
                'modList'=>'',
                'tables_select'=>'',
                'tables_modify'=>'',
                'pagetypes_select'=>'',
                'non_exclude_fields'=>'',
                'explicit_allowdeny'=>'',
                'allowed_languages' => '',
                'custom_options' => '',
        );
        var $includeHierarchy=array();          // For debugging/display of order in which subgroups are included.
        var $includeGroupArray=array();         // List of group_id's in the order they are processed.

        var $OS='';                                                     // Set to 'WIN', if windows
        var $TSdataArray=array();                       // Used to accumulate the TSconfig data of the user
        var $userTS_text = '';                          // Contains the non-parsed user TSconfig
        var $userTS = array();                          // Contains the parsed user TSconfig
        var $userTSUpdated=0;                           // Set internally if the user TSconfig was parsed and needs to be cached.
        var $userTS_dontGetCached=0;            // Set this from outside if you want the user TSconfig to ALWAYS be parsed and not fetched from cache.

        var $RTE_errors = array();                      // RTE availability errors collected.
        var $errorMsg = '';                                     // Contains last error message













        /************************************
         *
         * Permission checking functions:
         *
         ************************************/

        function isAdmin()      {
                return (($this->user['admin']&1) ==1);
        }

        function isMemberOfGroup($groupId)      {
                $groupId = intval($groupId);
                if ($this->groupList && $groupId)       {
                        return $this->inList($this->groupList, $groupId);
                }
        }

        function doesUserHaveAccess($row,$perms)        {
                $userPerms = $this->calcPerms($row);
                return ($userPerms & $perms)==$perms;
        }

        function isInWebMount($id,$readPerms='',$exitOnError=0) {
                if (!$GLOBALS['TYPO3_CONF_VARS']['BE']['lockBeUserToDBmounts'] || $this->isAdmin())     return 1;
                $id = intval($id);
                if (!$readPerms)        $readPerms = $this->getPagePermsClause(1);
                if ($id>0)      {
                        $wM = $this->returnWebmounts();
                        $rL = t3lib_BEfunc::BEgetRootLine($id,' AND '.$readPerms);

                        foreach($rL as $v)      {
                                if ($v['uid'] && in_array($v['uid'],$wM))       {
                                        return $v['uid'];
                                }
                        }
                }
                if ($exitOnError)       {
                        t3lib_BEfunc::typo3PrintError ('Access Error','This page is not within your DB-mounts',0);
                        exit;
                }
        }

        function modAccess($conf,$exitOnError)  {
                if (!t3lib_BEfunc::isModuleSetInTBE_MODULES($conf['name']))     {
                        if ($exitOnError)       {
                                t3lib_BEfunc::typo3PrintError ('Fatal Error','This module "'.$conf['name'].'" is not enabled in TBE_MODULES',0);
                                exit;
                        }
                        return false;
                }

                        // Returns true if conf[access] is not set at all or if the user is admin
                if (!$conf['access']  ||  $this->isAdmin()) return true;

                        // If $conf['access'] is set but not with 'admin' then we return true, if the module is found in the modList
                if (!strstr($conf['access'],'admin') && $conf['name'])  {
                        $acs = $this->check('modules',$conf['name']);
                }
                if (!$acs && $exitOnError)      {
                        t3lib_BEfunc::typo3PrintError ('Access Error','You don\'t have access to this module.',0);
                        exit;
                } else return $acs;
        }

        function getPagePermsClause($perms)     {
                if (is_array($this->user))      {
                        if ($this->isAdmin())   {
                                return ' 1=1';
                        }

                        $perms = intval($perms);        // Make sure it's integer.
                        $str= ' ('.
                                '(pages.perms_everybody & '.$perms.' = '.$perms.')'.    // Everybody
                                'OR(pages.perms_userid = '.$this->user['uid'].' AND pages.perms_user & '.$perms.' = '.$perms.')';       // User
                        if ($this->groupList){$str.='OR(pages.perms_groupid in ('.$this->groupList.') AND pages.perms_group & '.$perms.' = '.$perms.')';}       // Group (if any is set)
                        $str.=')';
                        return $str;
                } else {
                        return ' 1=0';
                }
        }

        function calcPerms($row)        {
                if ($this->isAdmin()) {return 31;}              // Return 31 for admin users.

                $out=0;
                if (isset($row['perms_userid']) && isset($row['perms_user']) && isset($row['perms_groupid']) && isset($row['perms_group']) && isset($row['perms_everybody']) && isset($this->groupList))        {
                        if ($this->user['uid']==$row['perms_userid'])   {
                                $out|=$row['perms_user'];
                        }
                        if ($this->isMemberOfGroup($row['perms_groupid']))      {
                                $out|=$row['perms_group'];
                        }
                        $out|=$row['perms_everybody'];
                }
                return $out;
        }

        function isRTE()        {
                global $CLIENT;

                        // Start:
                $this->RTE_errors = array();
                if (!$this->uc['edit_RTE'])
                        $this->RTE_errors[] = 'RTE is not enabled for user!';
                if (!$GLOBALS['TYPO3_CONF_VARS']['BE']['RTEenabled'])
                        $this->RTE_errors[] = 'RTE is not enabled in $TYPO3_CONF_VARS["BE"]["RTEenabled"]';


                        // Acquire RTE object:
                $RTE = &t3lib_BEfunc::RTEgetObj();
                if (!is_object($RTE))   {
                        $this->RTE_errors = array_merge($this->RTE_errors, $RTE);
                }

                if (!count($this->RTE_errors))  {
                        return TRUE;
                } else {
                        return FALSE;
                }
        }

        function check($type,$value)    {
                if (isset($this->groupData[$type]))     {
                        if ($this->isAdmin() || $this->inList($this->groupData[$type],$value)) {
                                return 1;
                        }
                }
        }

        function checkAuthMode($table,$field,$value,$authMode)  {
                global $TCA;

                        // Admin users can do anything:
                if ($this->isAdmin())   return TRUE;

                        // Allow all blank values:
                if (!strcmp($value,'')) return TRUE;

                        // Certain characters are not allowed in the value
                if (ereg('[:|,]',$value))       {
                        return FALSE;
                }

                        // Initialize:
                $testValue = $table.':'.$field.':'.$value;
                $out = TRUE;

                        // Checking value:
                switch((string)$authMode)       {
                        case 'explicitAllow':
                                if (!$this->inList($this->groupData['explicit_allowdeny'],$testValue.':ALLOW')) {
                                        $out = FALSE;
                                }
                        break;
                        case 'explicitDeny':
                                if ($this->inList($this->groupData['explicit_allowdeny'],$testValue.':DENY'))   {
                                        $out = FALSE;
                                }
                        break;
                        case 'individual':
                                t3lib_div::loadTCA($table);
                                if (is_array($TCA[$table]) && is_array($TCA[$table]['columns'][$field]))        {
                                        $items = $TCA[$table]['columns'][$field]['config']['items'];
                                        if (is_array($items))   {
                                                foreach($items as $iCfg)        {
                                                        if (!strcmp($iCfg[1],$value) && $iCfg[4])       {
                                                                switch((string)$iCfg[4])        {
                                                                        case 'EXPL_ALLOW':
                                                                                if (!$this->inList($this->groupData['explicit_allowdeny'],$testValue.':ALLOW')) {
                                                                                        $out = FALSE;
                                                                                }
                                                                        break;
                                                                        case 'EXPL_DENY':
                                                                                if ($this->inList($this->groupData['explicit_allowdeny'],$testValue.':DENY'))   {
                                                                                        $out = FALSE;
                                                                                }
                                                                        break;
                                                                }
                                                                break;
                                                        }
                                                }
                                        }
                                }
                        break;
                }

                return $out;
        }

        function checkLanguageAccess($langValue)        {
                if (strcmp($this->groupData['allowed_languages'],''))   {       // The users language list must be non-blank - otherwise all languages are allowed.
                        $langValue = intval($langValue);
                        if ($langValue != -1 && !$this->check('allowed_languages',$langValue))  {       // Language must either be explicitly allowed OR the lang Value be "-1" (all languages)
                                return FALSE;
                        }
                }
                return TRUE;
        }

        function recordEditAccessInternals($table,$idOrRow)     {
                global $TCA;

                if (isset($TCA[$table]))        {
                        t3lib_div::loadTCA($table);

                                // Always return true for Admin users.
                        if ($this->isAdmin())   return TRUE;

                                // Fetching the record if the $idOrRow variable was not an array on input:
                        if (!is_array($idOrRow))        {
                                $idOrRow = t3lib_BEfunc::getRecord($table, $idOrRow);
                                if (!is_array($idOrRow))        {
                                        $this->errorMsg = 'ERROR: Record could not be fetched.';
                                        return FALSE;
                                }
                        }

                                // Checking languages:
                        if ($TCA[$table]['ctrl']['languageField'])      {
                                if (isset($idOrRow[$TCA[$table]['ctrl']['languageField']]))     {       // Language field must be found in input row - otherwise it does not make sense.
                                        if (!$this->checkLanguageAccess($idOrRow[$TCA[$table]['ctrl']['languageField']]))       {
                                                $this->errorMsg = 'ERROR: Language was not allowed.';
                                                return FALSE;
                                        }
                                }
                        }

                                // Checking authMode fields:
                        if (is_array($TCA[$table]['columns']))  {
                                foreach($TCA[$table]['columns'] as $fN => $fV)  {
                                        if (isset($idOrRow[$fN]))       {       //
                                                if ($fV['config']['type']=='select' && $fV['config']['authMode'] && !strcmp($fV['config']['authMode_enforce'],'strict')) {
                                                        if (!$this->checkAuthMode($table,$fN,$idOrRow[$fN],$fV['config']['authMode']))  {
                                                                $this->errorMsg = 'ERROR: authMode "'.$fV['config']['authMode'].'" failed for field "'.$fN.'" with value "'.$idOrRow[$fN].'" evaluated';
                                                                return FALSE;
                                                        }
                                                }
                                        }
                                }
                        }

                                // Checking "editlock" feature
                        if ($TCA[$table]['ctrl']['editlock'] && $idOrRow[$TCA[$table]['ctrl']['editlock']])     {
                                $this->errorMsg = 'ERROR: Record was locked for editing. Only admin users can change this state.';
                                return FALSE;
                        }

                                // Checking record permissions
                        // THIS is where we can include a check for "perms_" fields for other records than pages...

                                // Finally, return true if all is well.
                        return TRUE;
                }
        }

        function isPSet($lCP,$table,$type='')   {
                if ($this->isAdmin())   return true;
                if ($table=='pages')    {
                        if ($type=='edit')      return $lCP & 2;
                        if ($type=='new')       return ($lCP & 8) || ($lCP & 16);       // Create new page OR pagecontent
                        if ($type=='delete')    return $lCP & 4;
                        if ($type=='editcontent')       return $lCP & 16;
                } else {
                        return $lCP & 16;
                }
        }

        function mayMakeShortcut()      {
                return $this->getTSConfigVal('options.shortcutFrame') && !$this->getTSConfigVal('options.mayNotCreateEditShortcuts');
        }










        /*************************************
         *
         * Miscellaneous functions
         *
         *************************************/

        function getTSConfig($objectString,$config='')  {
                if (!is_array($config)) {
                        $config=$this->userTS;  // Getting Root-ts if not sent
                }
                $TSConf=array();
                $parts = explode('.',$objectString,2);
                $key = $parts[0];
                if (trim($key)) {
                        if (count($parts)>1 && trim($parts[1])) {
                                // Go on, get the next level
                                if (is_array($config[$key.'.']))        $TSConf = $this->getTSConfig($parts[1],$config[$key.'.']);
                        } else {
                                $TSConf['value']=$config[$key];
                                $TSConf['properties']=$config[$key.'.'];
                        }
                }
                return $TSConf;
        }

        function getTSConfigVal($objectString)  {
                $TSConf = $this->getTSConfig($objectString);
                return $TSConf['value'];
        }

        function getTSConfigProp($objectString) {
                $TSConf = $this->getTSConfig($objectString);
                return $TSConf['properties'];
        }

        function inList($in_list,$item) {
                return strstr(','.$in_list.',', ','.$item.',');
        }

        function returnWebmounts()      {
                return (string)($this->groupData['webmounts'])!='' ? explode(',',$this->groupData['webmounts']) : Array();
        }

        function returnFilemounts()     {
                return $this->groupData['filemounts'];
        }












        /*************************************
         *
         * Authentication methods
         *
         *************************************/


        function fetchGroupData()       {
                if ($this->user['uid']) {

                                // Get lists for the be_user record and set them as default/primary values.
                        $this->dataLists['modList'] = $this->user['userMods'];                                  // Enabled Backend Modules
                        $this->dataLists['allowed_languages'] = $this->user['allowed_languages'];                                       // Add Allowed Languages
                        $this->dataLists['webmount_list'] = $this->user['db_mountpoints'];              // Database mountpoints
                        $this->dataLists['filemount_list'] = $this->user['file_mountpoints'];   // File mountpoints

                                // Setting default User TSconfig:
                        $this->TSdataArray[]=$this->addTScomment('From $GLOBALS["TYPO3_CONF_VARS"]["BE"]["defaultUserTSconfig"]:').
                                                                        $GLOBALS['TYPO3_CONF_VARS']['BE']['defaultUserTSconfig'];

                                // Default TSconfig for admin-users
                        if ($this->isAdmin())   {
                                $this->TSdataArray[]=$this->addTScomment('"admin" user presets:').'
                                        admPanel.enable.all = 1
                                        options.shortcutFrame = 1
                                ';
                                if (t3lib_extMgm::isLoaded('tt_news'))  {
                                        $this->TSdataArray[]='
                                                // Setting defaults for tt_news author / email...
                                                TCAdefaults.tt_news.author = '.$this->user['realName'].'
                                                TCAdefaults.tt_news.author_email = '.$this->user['email'].'
                                        ';
                                }
                                if (t3lib_extMgm::isLoaded('sys_note')) {
                                        $this->TSdataArray[]='
                                                // Setting defaults for sys_note author / email...
                                                TCAdefaults.sys_note.author = '.$this->user['realName'].'
                                                TCAdefaults.sys_note.email = '.$this->user['email'].'
                                        ';
                                }
                        }

                                // FILE MOUNTS:
                                // Admin users has the base fileadmin dir mounted
                        if ($this->isAdmin() && $GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'])      {
                                $this->addFileMount($GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'], '', PATH_site.$GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'], 0, '');
                        }

                                // If userHomePath is set, we attempt to mount it
                        if ($GLOBALS['TYPO3_CONF_VARS']['BE']['userHomePath'])  {
                                        // First try and mount with [uid]_[username]
                                $didMount=$this->addFileMount($this->user['username'], '',$GLOBALS['TYPO3_CONF_VARS']['BE']['userHomePath'].$this->user['uid'].'_'.$this->user['username'].$GLOBALS['TYPO3_CONF_VARS']['BE']['userUploadDir'], 0, 'user');
                                if (!$didMount) {
                                                // If that failed, try and mount with only [uid]
                                        $this->addFileMount($this->user['username'], '', $GLOBALS['TYPO3_CONF_VARS']['BE']['userHomePath'].$this->user['uid'].$GLOBALS['TYPO3_CONF_VARS']['BE']['userUploadDir'], 0, 'user');
                                }
                        }

                                // BE_GROUPS:
                                // Get the groups...
#                       $grList = t3lib_BEfunc::getSQLselectableList($this->user[$this->usergroup_column],$this->usergroup_table,$this->usergroup_table);
                        $grList = $GLOBALS['TYPO3_DB']->cleanIntList($this->user[$this->usergroup_column]);     // 240203: Since the group-field never contains any references to groups with a prepended table name we think it's safe to just intExplode and re-implode - which should be much faster than the other function call.
                        if ($grList)    {
                                        // Fetch groups will add a lot of information to the internal arrays: modules, accesslists, TSconfig etc. Refer to fetchGroups() function.
                                $this->fetchGroups($grList);
                        }

                                // Add the TSconfig for this specific user:
                        $this->TSdataArray[] = $this->addTScomment('USER TSconfig field').$this->user['TSconfig'];
                                // Check include lines.
                        $this->TSdataArray = t3lib_TSparser::checkIncludeLines_array($this->TSdataArray);

                                // Parsing the user TSconfig (or getting from cache)
                        $this->userTS_text = implode(chr(10).'[GLOBAL]'.chr(10),$this->TSdataArray);    // Imploding with "[global]" will make sure that non-ended confinements with braces are ignored.
                        $hash = md5('userTS:'.$this->userTS_text);
                        $cachedContent = t3lib_BEfunc::getHash($hash,0);
                        if (isset($cachedContent) && !$this->userTS_dontGetCached)      {
                                $this->userTS = unserialize($cachedContent);
                        } else {
                                $parseObj = t3lib_div::makeInstance('t3lib_TSparser');
                                $parseObj->parse($this->userTS_text);
                                $this->userTS = $parseObj->setup;
                                t3lib_BEfunc::storeHash($hash,serialize($this->userTS),'BE_USER_TSconfig');
                                        // Update UC:
                                $this->userTSUpdated=1;
                        }

                                // Processing webmounts
                        if ($this->isAdmin() && !$this->getTSConfigVal('options.dontMountAdminMounts')) {       // Admin's always have the root mounted
                                $this->dataLists['webmount_list']='0,'.$this->dataLists['webmount_list'];
                        }

                                // Processing filemounts
                        $this->dataLists['filemount_list'] = t3lib_div::uniqueList($this->dataLists['filemount_list']);
                        if ($this->dataLists['filemount_list']) {
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_filemounts', 'NOT deleted AND NOT hidden AND pid=0 AND uid IN ('.$this->dataLists['filemount_list'].')');
                                while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
                                        $this->addFileMount($row['title'], $row['path'], $row['path'], $row['base']?1:0, '');
                                }
                        }

                                // The lists are cleaned for duplicates
                        $this->groupData['webmounts'] = t3lib_div::uniqueList($this->dataLists['webmount_list']);
                        $this->groupData['pagetypes_select'] = t3lib_div::uniqueList($this->dataLists['pagetypes_select']);
                        $this->groupData['tables_select'] = t3lib_div::uniqueList($this->dataLists['tables_modify'].','.$this->dataLists['tables_select']);
                        $this->groupData['tables_modify'] = t3lib_div::uniqueList($this->dataLists['tables_modify']);
                        $this->groupData['non_exclude_fields'] = t3lib_div::uniqueList($this->dataLists['non_exclude_fields']);
                        $this->groupData['explicit_allowdeny'] = t3lib_div::uniqueList($this->dataLists['explicit_allowdeny']);
                        $this->groupData['allowed_languages'] = t3lib_div::uniqueList($this->dataLists['allowed_languages']);
                        $this->groupData['custom_options'] = t3lib_div::uniqueList($this->dataLists['custom_options']);
                        $this->groupData['modules'] = t3lib_div::uniqueList($this->dataLists['modList']);

                                // populating the $this->userGroupsUID -array with the groups in the order in which they were LAST included.!!
                        $this->userGroupsUID = array_reverse(array_unique(array_reverse($this->includeGroupArray)));

                                // Finally this is the list of group_uid's in the order they are parsed (including subgroups!) and without duplicates (duplicates are presented with their last entrance in the list, which thus reflects the order of the TypoScript in TSconfig)
                        $this->groupList = implode(',',$this->userGroupsUID);
                        $this->setCachedList($this->groupList);
                }
        }

        function fetchGroups($grList,$idList='')        {

                        // Fetching records of the groups in $grList (which are not blocked by lockedToDomain either):
                $lockToDomain_SQL = ' AND (lockToDomain="" OR lockToDomain="'.t3lib_div::getIndpEnv('HTTP_HOST').'")';
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', $this->usergroup_table, 'NOT deleted AND NOT hidden AND pid=0 AND uid IN ('.$grList.')'.$lockToDomain_SQL);

                        // The userGroups array is filled
                while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
                        $this->userGroups[$row['uid']] = $row;
                }

                        // Traversing records in the correct order
                $include_staticArr = t3lib_div::intExplode(',',$grList);
                reset($include_staticArr);
                while(list(,$uid)=each($include_staticArr))     {       // traversing list

                                // Get row:
                        $row=$this->userGroups[$uid];
                        if (is_array($row) && !t3lib_div::inList($idList,$uid)) {       // Must be an array and $uid should not be in the idList, because then it is somewhere previously in the grouplist

                                        // Include sub groups
                                if (trim($row['subgroup']))     {
                                        $theList = implode(',',t3lib_div::intExplode(',',$row['subgroup']));    // Make integer list
                                        $this->fetchGroups($theList, $idList.','.$uid);         // Call recursively, pass along list of already processed groups so they are not recursed again.
                                }
                                        // Add the group uid, current list, TSconfig to the internal arrays.
                                $this->includeGroupArray[]=$uid;
                                $this->includeHierarchy[]=$idList;
                                $this->TSdataArray[] = $this->addTScomment('Group "'.$row['title'].'" ['.$row['uid'].'] TSconfig field:').$row['TSconfig'];

                                        // Mount group database-mounts
                                if (($this->user['options']&1) == 1)    {       $this->dataLists['webmount_list'].= ','.$row['db_mountpoints']; }

                                        // Mount group file-mounts
                                if (($this->user['options']&2) == 2)    {       $this->dataLists['filemount_list'].= ','.$row['file_mountpoints'];      }

                                        // Mount group home-dirs
                                if (($this->user['options']&2) == 2)    {
                                                // If groupHomePath is set, we attempt to mount it
                                        if ($GLOBALS['TYPO3_CONF_VARS']['BE']['groupHomePath']) {
                                                $this->addFileMount($row['title'], '', $GLOBALS['TYPO3_CONF_VARS']['BE']['groupHomePath'].$row['uid'], 0, 'group');
                                        }
                                }

                                        // The lists are made: groupMods, tables_select, tables_modify, pagetypes_select, non_exclude_fields, explicit_allowdeny, allowed_languages, custom_options
                                if ($row['inc_access_lists']==1)        {
                                        $this->dataLists['modList'].= ','.$row['groupMods'];
                                        $this->dataLists['tables_select'].= ','.$row['tables_select'];
                                        $this->dataLists['tables_modify'].= ','.$row['tables_modify'];
                                        $this->dataLists['pagetypes_select'].= ','.$row['pagetypes_select'];
                                        $this->dataLists['non_exclude_fields'].= ','.$row['non_exclude_fields'];
                                        $this->dataLists['explicit_allowdeny'].= ','.$row['explicit_allowdeny'];
                                        $this->dataLists['allowed_languages'].= ','.$row['allowed_languages'];
                                        $this->dataLists['custom_options'].= ','.$row['custom_options'];
                                }
                                        // If this function is processing the users OWN group-list (not subgroups) AND if the ->firstMainGroup is not set, then the ->firstMainGroup will be set.
                                if (!strcmp($idList,'') && !$this->firstMainGroup)      {
                                        $this->firstMainGroup=$uid;
                                }
                        }
                }

        }

        function setCachedList($cList)  {
                if ((string)$cList != (string)$this->user['usergroup_cached_list'])     {
                        $GLOBALS['TYPO3_DB']->exec_UPDATEquery('be_users', 'uid='.intval($this->user['uid']), array('usergroup_cached_list' => $cList));
                }
        }

        function addFileMount($title, $altTitle, $path, $webspace, $type)       {
                        // Return false if fileadminDir is not set and we try to mount a relative path
                if ($webspace && !$GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'])    return false;

                        // Trimming and pre-processing
                $path=trim($path);
                if ($this->OS=='WIN')   {               // with WINDOWS convert backslash to slash!!
                        $path=str_replace('\\','/',$path);
                }
                        // If the path is true and validates as a valid path string:
                if ($path && t3lib_div::validPathStr($path))    {
                                // these lines remove all slashes and dots before and after the path
                        $path=ereg_replace('^[\/\. ]*','',$path);
                        $path=trim(ereg_replace('[\/\. ]*$','',$path));


                        if ($path)      {       // there must be some chars in the path
                                $fdir=PATH_site.$GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'];      // fileadmin dir, absolute
                                if ($webspace)  {
                                        $path=$fdir.$path;      // PATH_site + fileadmin dir is prepended
                                } else {
                                        if ($this->OS!='WIN')   {               // with WINDOWS no prepending!!
                                                $path='/'.$path;        // root-level is the start...
                                        }
                                }
                                $path.='/';

                                        // We now have a path with slash after and slash before (if unix)
                                if (@is_dir($path) &&
                                        (($GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath'] && t3lib_div::isFirstPartOfStr($path,$GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath'])) || t3lib_div::isFirstPartOfStr($path,$fdir)))      {
                                                        // Alternative title?
                                                $name = $title ? $title : $altTitle;
                                                        // Adds the filemount. The same filemount with same name, type and path cannot be set up twice because of the hash string used as key.
                                                $this->groupData['filemounts'][md5($name.'|'.$path.'|'.$type)] = Array('name'=>$name, 'path'=>$path, 'type'=>$type);
                                                        // Return true - went well, success!
                                                return 1;
                                }
                        }
                }
        }

        function addTScomment($str)     {
                $delimiter = '# ***********************************************';

                $out = $delimiter.chr(10);
                $lines = t3lib_div::trimExplode(chr(10),$str);
                foreach($lines as $v)   {
                        $out.= '# '.$v.chr(10);
                }
                $out.= $delimiter.chr(10);
                return $out;
        }












        /************************************
         *
         * Logging
         *
         ************************************/


        function writelog($type,$action,$error,$details_nr,$details,$data,$tablename='',$recuid='',$recpid='',$event_pid=-1,$NEWid='') {

                $fields_values = Array (
                        'userid' => intval($this->user['uid']),
                        'type' => intval($type),
                        'action' => intval($action),
                        'error' => intval($error),
                        'details_nr' => intval($details_nr),
                        'details' => $details,
                        'log_data' => serialize($data),
                        'tablename' => $tablename,
                        'recuid' => intval($recuid),
                        'recpid' => intval($recpid),
                        'IP' => t3lib_div::getIndpEnv('REMOTE_ADDR'),
                        'tstamp' => $GLOBALS['EXEC_TIME'],
                        'event_pid' => intval($event_pid),
                        'NEWid' => $NEWid
                );

                $GLOBALS['TYPO3_DB']->exec_INSERTquery('sys_log', $fields_values);
                return $GLOBALS['TYPO3_DB']->sql_insert_id();
        }

        function checkLogFailures($email, $secondsBack=3600, $max=3)    {
                if ($email)     {

                                // get last flag set in the log for sending
                        $theTimeBack = time()-$secondsBack;
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                                        'tstamp',
                                                        'sys_log',
                                                        'type=255 AND action=4 AND tstamp>'.intval($theTimeBack),
                                                        '',
                                                        'tstamp DESC',
                                                        '1'
                                                );
                        if ($testRow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))     {
                                $theTimeBack = $testRow['tstamp'];
                        }

                                // Check for more than $max number of error failures with the last period.
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                                        '*',
                                                        'sys_log',
                                                        'type=255 AND action=3 AND error!=0 AND tstamp>'.intval($theTimeBack),
                                                        '',
                                                        'tstamp'
                                                );
                        if ($GLOBALS['TYPO3_DB']->sql_num_rows($res) > $max)    {
                                        // OK, so there were more than the max allowed number of login failures - so we will send an email then.
                                $subject = 'TYPO3 Login Failure Warning (at '.$GLOBALS['TYPO3_CONF_VARS']['SYS']['sitename'].')';
                                $email_body = '
There has been numerous attempts ('.$GLOBALS['TYPO3_DB']->sql_num_rows($res).') to login at the TYPO3
site "'.$GLOBALS['TYPO3_CONF_VARS']['SYS']['sitename'].'" ('.t3lib_div::getIndpEnv('HTTP_HOST').').

This is a dump of the failures:

';
                                while($testRows = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
                                        $theData = unserialize($testRows['log_data']);
                                        $email_body.=date($GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'].' H:i',$testRows['tstamp']).':  '.@sprintf($testRows['details'],''.$theData[0],''.$theData[1],''.$theData[2]);
                                        $email_body.=chr(10);
                                }
                                mail(   $email,
                                                $subject,
                                                $email_body,
                                                'From: TYPO3 Login WARNING<>'
                                );
                                $this->writelog(255,4,0,3,'Failure warning (%s failures within %s seconds) sent by email to %s',Array($GLOBALS['TYPO3_DB']->sql_num_rows($res),$secondsBack,$email));   // Logout written to log
                        }
                }
        }
}



if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_userauthgroup.php'])     {
        include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_userauthgroup.php']);
}
?>

---