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.tslib_feuserauth.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2005 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!
***************************************************************/
class tslib_feUserAuth extends t3lib_userAuth {
        var $session_table = 'fe_sessions';             // Table to use for session data.
        var $name = 'fe_typo_user';                 // Session/Cookie name
        var $get_name = 'ftu';                                   // Session/GET-var name

        var $user_table = 'fe_users';                                   // Table in database with userdata
        var $username_column = 'username';                              // Column for login-name
        var $userident_column = 'password';                     // Column for password
        var $userid_column = 'uid';                                     // Column for user-id
        var $lastLogin_column = 'lastlogin';

        var $enablecolumns = Array (
                'deleted' => 'deleted',
                'disabled' => 'disable',
                'starttime' => 'starttime',
                'endtime' => 'endtime'
        );
        var $formfield_uname = 'user';                          // formfield with login-name
        var $formfield_uident = 'pass';                         // formfield with password
        var $formfield_chalvalue = 'challenge';         // formfield with a unique value which is used to encrypt the password and username
        var $formfield_status = 'logintype';            // formfield with status: *'login', 'logout'
        var $formfield_permanent = 'permalogin';        // formfield with 0 or 1 // 1 = permanent login enabled // 0 = session is valid for a browser session only
        var $security_level = '';                                       // sets the level of security. *'normal' = clear-text. 'challenged' = hashed password/username from form in $formfield_uident. 'superchallenged' = hashed password hashed again with username.

        var $auth_include = '';                                         // this is the name of the include-file containing the login form. If not set, login CAN be anonymous. If set login IS needed.

        var $auth_timeout_field = 6000;                         // Server session lifetime. If > 0: session-timeout in seconds. If false or <0: no timeout. If string: The string is a fieldname from the usertable where the timeout can be found.

        var $lifetime = 0;                              // Client session lifetime. 0 = Session-cookies. If session-cookies, the browser will stop the session when the browser is closed. Otherwise this specifies the lifetime of a cookie that keeps the session.
        var $sendNoCacheHeaders = 0;
        var $getFallBack = 1;                                           // If this is set, authentication is also accepted by the _GET. Notice that the identification is NOT 128bit MD5 hash but reduced. This is done in order to minimize the size for mobile-devices, such as WAP-phones
        var $hash_length = 10;
        var $getMethodEnabled = 1;                                      // Login may be supplied by url.

        var $usergroup_column = 'usergroup';
        var $usergroup_table = 'fe_groups';
        var $groupData = Array(
                'title' =>Array(),
                'uid' =>Array(),
                'pid' =>Array()
        );
        var $TSdataArray=array();               // Used to accumulate the TSconfig data of the user
        var $userTS = array();
        var $userTSUpdated=0;
        var $showHiddenRecords=0;

                // Session and user data:
                /*
                        There are two types of data that can be stored: UserData and Session-Data. Userdata is for the login-user, and session-data for anyone viewing the pages.
                        'Keys' are keys in the internal dataarray of the data. When you get or set a key in one of the data-spaces (user or session) you decide the type of the variable (not object though)
                        'Reserved' keys are:
                                - 'recs': Array: Used to 'register' records, eg in a shopping basket. Structure: [recs][tablename][record_uid]=number
                                - sys: Reserved for TypoScript standard code.
                */
        var $sesData = Array();
        var $sesData_change = 0;
        var $userData_change = 0;


        function start() {
                if (intval($this->auth_timeout_field)>0 && intval($this->auth_timeout_field) < $this->lifetime) {
                                // If server session timeout is non-zero but less than client session timeout: Copy this value instead.
                        $this->auth_timeout_field = $this->lifetime;
                }

                parent::start();
        }

        function getNewSessionRecord($tempuser) {
                $insertFields = parent::getNewSessionRecord($tempuser);
                $insertFields['ses_permanent'] = $this->is_permanent;

                return $insertFields;
        }

        function isSetSessionCookie() {
                $retVal = ($this->newSessionID || $this->forceSetCookie) && ($this->lifetime==0 || !$this->user['ses_permanent']);
                return $retVal;
        }

        function isRefreshTimeBasedCookie() {
                return $this->lifetime > 0 && $this->user['ses_permanent'];
        }

        function getLoginFormData() {
                $loginData = parent::getLoginFormData();
                if($GLOBALS['TYPO3_CONF_VARS']['FE']['permalogin'] == 0 || $GLOBALS['TYPO3_CONF_VARS']['FE']['permalogin'] == 1) {
                        if ($this->getMethodEnabled)    {
                                $isPermanent = t3lib_div::_GP($this->formfield_permanent);
                        } else {
                                $isPermanent = t3lib_div::_POST($this->formfield_permanent);
                        }
                        if(strlen($isPermanent) != 1) {
                                $isPermanent = $GLOBALS['TYPO3_CONF_VARS']['FE']['permalogin'];
                        } elseif(!$isPermanent) {
                                $this->forceSetCookie = true; // To make sure the user gets a session cookie and doesn't keep a possibly existing time based cookie, we need to force seeting the session cookie here
                        }
                        $isPermanent = $isPermanent?1:0;
                } elseif($GLOBALS['TYPO3_CONF_VARS']['FE']['permalogin'] == 2) {
                        $isPermanent = 1;
                } else {
                        $isPermanent = 0;
                }
                $loginData['permanent'] = $isPermanent;
                $this->is_permanent = $isPermanent;

                return $loginData;
        }

        function fetchGroupData()       {
                $this->TSdataArray = array();
                $this->userTS = array();
                $this->userTSUpdated = 0;
                $this->groupData = Array(
                        'title' => Array(),
                        'uid' => Array(),
                        'pid' => Array()
                );

                        // Setting default configuration:
                $this->TSdataArray[]=$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultUserTSconfig'];

                        // get the info data for auth services
                $authInfo = $this->getAuthInfoArray();

                if ($this->writeDevLog)         t3lib_div::devLog('Get usergroups for user: '.t3lib_div::arrayToLogString($this->user, array($this->userid_column,$this->username_column)), 'tslib_feUserAuth');

                $groupDataArr = array();

                        // use 'auth' service to find the groups for the user
                $serviceChain='';
                $subType = 'getGroups'.$this->loginType;
                while (is_object($serviceObj = t3lib_div::makeInstanceService('auth', $subType, $serviceChain)))        {
                        $serviceChain.=','.$serviceObj->getServiceKey();
                        $serviceObj->initAuth($subType, array(), $authInfo, $this);

                        $groupData = $serviceObj->getGroups($this->user, $groupDataArr);
                        if (is_array($groupData) && count($groupData))  {
                                $groupDataArr = t3lib_div::array_merge($groupDataArr, $groupData);      // Keys in $groupData should be unique ids of the groups (like "uid") so this function will override groups.
                        }
                        unset($serviceObj);
                }
                if ($this->writeDevLog AND $serviceChain)       t3lib_div::devLog($subType.' auth services called: '.$serviceChain, 'tslib_feUserAuth');
                if ($this->writeDevLog AND !count($groupDataArr))       t3lib_div::devLog('No usergroups found by services', 'tslib_feUserAuth');
                if ($this->writeDevLog AND count($groupDataArr))        t3lib_div::devLog(count($groupDataArr).' usergroup records found by services', 'tslib_feUserAuth');


                        // use 'auth' service to check the usergroups if they are really valid
                foreach ($groupDataArr as $groupData)   {
                                // by default a group is valid
                        $validGroup = TRUE;

                        $serviceChain='';
                        $subType = 'authGroups'.$this->loginType;
                        while (is_object($serviceObj = t3lib_div::makeInstanceService('auth', $subType, $serviceChain))) {
                                $serviceChain.=','.$serviceObj->getServiceKey();
                                $serviceObj->initAuth($subType, array(), $authInfo, $this);

                                if (!$serviceObj->authGroup($this->user, $groupData)) {
                                        $validGroup = FALSE;
                                        if ($this->writeDevLog)         t3lib_div::devLog($subType.' auth service did not auth group: '.t3lib_div::arrayToLogString($groupData, 'uid,title'), 'tslib_feUserAuth', 2);

                                        break;
                                }
                                unset($serviceObj);
                        }
                        unset($serviceObj);

                        if ($validGroup) {
                                $this->groupData['title'][$groupData['uid']]=$groupData['title'];
                                $this->groupData['uid'][$groupData['uid']]=$groupData['uid'];
                                $this->groupData['pid'][$groupData['uid']]=$groupData['pid'];
                                $this->groupData['TSconfig'][$groupData['uid']]=$groupData['TSconfig'];
                        }
                }

                if (count($this->groupData) && count($this->groupData['TSconfig']))     {
                                // TSconfig: collect it in the order it was collected
                        foreach($this->groupData['TSconfig'] as $TSdata)        {
                                $this->TSdataArray[]=$TSdata;
                        }

                        $this->TSdataArray[]=$this->user['TSconfig'];

                                // Sort information
                        ksort($this->groupData['title']);
                        ksort($this->groupData['uid']);
                        ksort($this->groupData['pid']);
                }

                return count($this->groupData['uid']) ? count($this->groupData['uid']) : 0;
        }

        function getUserTSconf()        {
                if (!$this->userTSUpdated) {
                                // Parsing the user TS (or getting from cache)
                        $this->TSdataArray = t3lib_TSparser::checkIncludeLines_array($this->TSdataArray);
                        $userTS = implode(chr(10).'[GLOBAL]'.chr(10),$this->TSdataArray);
                        $parseObj = t3lib_div::makeInstance('t3lib_TSparser');
                        $parseObj->parse($userTS);
                        $this->userTS = $parseObj->setup;

                        $this->userTSUpdated=1;
                }
                return $this->userTS;
        }

















        /*****************************************
         *
         * Session data management functions
         *
         ****************************************/

        function fetchSessionData()     {
                // Gets SesData if any
                if ($this->id)  {
                        $dbres = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'fe_session_data', 'hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($this->id, 'fe_session_data'));
                        if ($sesDataRow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($dbres))        {
                                $this->sesData = unserialize($sesDataRow['content']);
                        }
                }
                        // delete old data:
                if ((rand()%100) <= 1) {                // a possibility of 1 % for garbage collection.
                        $GLOBALS['TYPO3_DB']->exec_DELETEquery('fe_session_data', 'tstamp < '.intval(time()-3600*24));          // all data older than 24 hours are deleted.
                }
        }

        function storeSessionData()     {
                        // Saves UC and SesData if changed.
                if ($this->userData_change)     {
                        $this->writeUC('');
                }
                if ($this->sesData_change)      {
                        if ($this->id)  {
                                $insertFields = array (
                                        'hash' => $this->id,
                                        'content' => serialize($this->sesData),
                                        'tstamp' => time()
                                );
                                $GLOBALS['TYPO3_DB']->exec_DELETEquery('fe_session_data', 'hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($this->id, 'fe_session_data'));
                                $GLOBALS['TYPO3_DB']->exec_INSERTquery('fe_session_data', $insertFields);
                        }
                }
        }

        function getKey($type,$key) {
                if ($key)       {
                        switch($type)   {
                                case 'user':
                                        return $this->uc[$key];
                                break;
                                case 'ses':
                                        return $this->sesData[$key];
                                break;
                        }
                }
        }

        function setKey($type,$key,$data)       {
                if ($key)       {
                        switch($type)   {
                                case 'user':
                                        if ($this->user['uid']) {
                                                $this->uc[$key]=$data;
                                                $this->userData_change=1;
                                        }
                                break;
                                case 'ses':
                                        $this->sesData[$key]=$data;
                                        $this->sesData_change=1;
                                break;
                        }
                }
        }

        function record_registration($recs,$maxSizeOfSessionData=0)     {

                        // Storing value ONLY if there is a confirmed cookie set (->cookieID), otherwise a shellscript could easily be spamming the fe_sessions table with bogus content and thus bloat the database
                if (!$maxSizeOfSessionData || $this->cookieId===$this->id)      {
                        if ($recs['clear_all']) {
                                $this->setKey('ses','recs','');
                        }
                        $change=0;
                        $recs_array=$this->getKey('ses','recs');
                        reset($recs);
                        while(list($table,$data)=each($recs))   {
                                if (is_array($data))    {
                                        reset($data);
                                        while(list($rec_id,$value)=each($data)) {
                                                if ($value != $recs_array[$table][$rec_id])     {
                                                        $recs_array[$table][$rec_id] = $value;
                                                        $change=1;
                                                }
                                        }
                                }
                        }
                        if ($change && (!$maxSizeOfSessionData || strlen(serialize($recs_array))<$maxSizeOfSessionData))        {
                                $this->setKey('ses','recs',$recs_array);
                        }
                }
        }
}


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

---