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

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2007 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_fe {

                // CURRENT PAGE:
        var $id='';                                                     // The page id (int)
        var $type='';                                           // RO The type (int)
        var $idParts=array();                           // Loaded with the id, exploded by ','
        var $cHash='';                                          // The submitted cHash
        var $no_cache='';                                       // Page will not be cached. Write only true. Never clear value (some other code might have reasons to set it true)
        var $rootLine='';                                       // The rootLine (all the way to tree root, not only the current site!) (array)
        var $page='';                                           // The pagerecord (array)
        var $contentPid=0;                                      // This will normally point to the same value as id, but can be changed to point to another page from which content will then be displayed instead.
        var $sys_page='';                                       // The object with pagefunctions (object)
        var $jumpurl='';
        var $pageNotFound=0;                            // Is set to 1 if a pageNotFound handler could have been called.
        var $domainStartPage=0;                         // Domain start page
        var $pageAccessFailureHistory=array();  // Array containing a history of why a requested page was not accessible.
        var $MP='';
        var $RDCT='';
        var $page_cache_reg1=0;                         // This can be set from applications as a way to tag cached versions of a page and later perform some external cache management, like clearing only a part of the cache of a page...
        var $siteScript='';                                     // Contains the value of the current script path that activated the frontend. Typically "index.php" but by rewrite rules it could be something else! Used for Speaking Urls / Simulate Static Documents.

                // USER
        var $fe_user='';                                        // The user (object)
        var $loginUser='';                                      // Global flag indicating that a front-end user is logged in. This is set only if a user really IS logged in. The group-list may show other groups (like added by IP filter or so) even though there is no user.
        var $gr_list='';                                        // (RO=readonly) The group list, sorted numerically. Group '0,-1' is the default group, but other groups may be added by other means than a user being logged in though...
        var $beUserLogin='';                            // Flag that indicates if a Backend user is logged in!
        var $workspacePreview='';                       // Integer, that indicates which workspace is being previewed.
        var $loginAllowedInBranch = TRUE;       // Shows whether logins are allowed in branch
        var $ADMCMD_preview_BEUSER_uid = 0;     // Integer, set to backend user ID to initialize when keyword-based preview is used.

                // PREVIEW
        var $fePreview='';                                      // Flag indication that preview is active. This is based on the login of a backend user and whether the backend user has read access to the current page. A value of 1 means ordinary preview, 2 means preview of a non-live workspace
        var $showHiddenPage='';                         // Flag indicating that hidden pages should be shown, selected and so on. This goes for almost all selection of pages!
        var $showHiddenRecords='';                      // Flag indicating that hidden records should be shown. This includes sys_template, pages_language_overlay and even fe_groups in addition to all other regular content. So in effect, this includes everything except pages.
        var $simUserGroup='0';                          // Value that contains the simulated usergroup if any

                // CONFIGURATION
        var $TYPO3_CONF_VARS=array();           // The configuration array as set up in t3lib/config_default.php. Should be an EXACT copy of the global array.
        var $config='';                                         // 'CONFIG' object from TypoScript. Array generated based on the TypoScript configuration of the current page. Saved with the cached pages.
        var $TCAcachedExtras=array();           // Array of cached information from TCA. This is NOT TCA itself!

                // TEMPLATE / CACHE
        var $tmpl='';                                           // The TypoScript template object. Used to parse the TypoScript template
        var $cacheTimeOutDefault='';            // Is set to the time-to-live time of cached pages. If false, default is 60*60*24, which is 24 hours.
        var $cacheContentFlag='';                       // Set internally if cached content is fetched from the database
        var $cacheExpires=0;                            // Set to the expire time of cached content
        var $isClientCachable=FALSE;            // Set if cache headers allowing caching are sent.
        var $all='';                                            // $all used by template fetching system. This array is an identification of the template. If $this->all is empty it's because the template-data is not cached, which it must be.
        var $sPre='';                                           // toplevel - objArrayName, eg 'page'
        var $pSetup='';                                         // TypoScript configuration of the page-object pointed to by sPre. $this->tmpl->setup[$this->sPre.'.']
        var $newHash='';                                        // This hash is unique to the template, the $this->id and $this->type vars and the gr_list (list of groups). Used to get and later store the cached data
        var $getMethodUrlIdToken='';            // If config.ftu (Frontend Track User) is set in TypoScript for the current page, the string value of this var is substituted in the rendered source-code with the string, '&ftu=[token...]' which enables GET-method usertracking as opposed to cookie based
        var $no_CacheBeforePageGen='';          // This flag is set before inclusion of pagegen.php IF no_cache is set. If this flag is set after the inclusion of pagegen.php, no_cache is forced to be set. This is done in order to make sure that php-code from pagegen does not falsely clear the no_cache flag.
        var $tempContent = FALSE;                       // This flag indicates if temporary content went into the cache during page-generation.
        var $forceTemplateParsing='';                           // Boolean, passed to TypoScript template class and tells it to render the template forcibly
        var $cHash_array=array();                       // The array which cHash_calc is based on, see ->makeCacheHash().
        var $hash_base='';                                      // Loaded with the serialized array that is used for generating a hashstring for the cache
        var $pagesTSconfig='';                          // May be set to the pagesTSconfig
                // PAGE-GENERATION / cOBJ
        /*
                Eg. insert JS-functions in this array ($additionalHeaderData) to include them once. Use associative keys.
                Keys in use:
                        JSFormValidate  :               <script type="text/javascript" src="'.$GLOBALS["TSFE"]->absRefPrefix.'t3lib/jsfunc.validateform.js"></script>
                        JSincludeFormupdate :   <script type="text/javascript" src="t3lib/jsfunc.updateform.js"></script>
                        JSMenuCode, JSMenuCode_menu :                   JavaScript for the JavaScript menu
                        JSCode : reserved
                        JSImgCode : reserved
        */
        var $additionalHeaderData=array();      // used to accumulate additional HTML-code for the header-section, <head>...</head>. Insert either associative keys (like additionalHeaderData['myStyleSheet'], see reserved keys above) or num-keys (like additionalHeaderData[] = '...')
        var $additionalJavaScript=array();      // used to accumulate additional JavaScript-code. Works like additionalHeaderData. Reserved keys at 'openPic' and 'mouseOver'
        var $additionalCSS=array();                     // used to accumulate additional Style code. Works like additionalHeaderData.
        var $JSeventFuncCalls = array(          // you can add JavaScript functions to each entry in these arrays. Please see how this is done in the GMENU_LAYERS script. The point is that many applications on a page can set handlers for onload, onmouseover and onmouseup
                'onmousemove' => array(),
                'onmouseup' => array(),
                'onmousemove' => array(),
                'onkeydown' => array(),
                'onkeyup' => array(),
                'onkeypress' => array(),
                'onload' => array(),
                'onunload' => array(),
        );
        var $JSCode='';                                         // Deprecated, use additionalJavaScript instead.
        var $JSImgCode='';                                      // Used to accumulate JavaScript loaded images (by menus)
        var $divSection='';                                     // Used to accumulate DHTML-layers.
        var $defaultBodyTag='<body>';           // Default bodytag, if nothing else is set. This can be overridden by applications like TemplaVoila.

                // RENDERING configuration, settings from TypoScript is loaded into these vars. See pagegen.php
        var $debug='';                                          // Debug flag, may output special debug html-code.
        var $intTarget='';                                      // Default internal target
        var $extTarget='';                                      // Default external target
        var $MP_defaults=array();                       // Keys are page ids and values are default &MP (mount point) values to set when using the linking features...)
        var $spamProtectEmailAddresses=0;       // If set, typolink() function encrypts email addresses. Is set in pagegen-class.
        var $absRefPrefix='';                           // Absolute Reference prefix
        var $absRefPrefix_force=0;                      // Absolute Reference prefix force flag. This is set, if the type and id is retrieve from PATH_INFO and thus we NEED to prefix urls with at least '/'
        var $compensateFieldWidth='';           // Factor for form-field widths compensation
        var $lockFilePath='';                           // Lock file path
        var $ATagParams='';                                     // <A>-tag parameters
        var $sWordRegEx='';                                     // Search word regex, calculated if there has been search-words send. This is used to mark up the found search words on a page when jumped to from a link in a search-result.
        var $sWordList='';                                      // Is set to the incoming array sword_list in case of a page-view jumped to from a search-result.
        var $linkVars='';                                       // A string prepared for insertion in all links on the page as url-parameters. Based on configuration in TypoScript where you defined which GET_VARS you would like to pass on.
        var $excludeCHashVars='';                       // A string set with a comma list of additional GET vars which should NOT be included in the cHash calculation. These vars should otherwise be detected and involved in caching, eg. through a condition in TypoScript.
        var $displayEditIcons='';                       // If set, edit icons are rendered aside content records. Must be set only if the ->beUserLogin flag is set and set_no_cache() must be called as well.
        var $displayFieldEditIcons='';          // If set, edit icons are rendered aside individual fields of content. Must be set only if the ->beUserLogin flag is set and set_no_cache() must be called as well.
        var $sys_language_uid=0;                        // Site language, 0 (zero) is default, int+ is uid pointing to a sys_language record. Should reflect which language menus, templates etc is displayed in (master language) - but not necessarily the content which could be falling back to default (see sys_language_content)
        var $sys_language_mode='';                      // Site language mode for content fall back.
        var $sys_language_content=0;            // Site content selection uid (can be different from sys_language_uid if content is to be selected from a fall-back language. Depends on sys_language_mode)
        var $sys_language_contentOL=0;          // Site content overlay flag; If set - and sys_language_content is > 0 - , records selected will try to look for a translation pointing to their uid. (If configured in [ctrl][languageField] / [ctrl][transOrigP...]
        var $sys_language_isocode = '';         // Is set to the iso code of the sys_language_content if that is properly defined by the sys_language record representing the sys_language_uid. (Requires the extension "static_info_tables")

                // RENDERING data
        var $applicationData=Array();           //       'Global' Storage for various applications. Keys should be 'tx_'.extKey for extensions.
        var $register=Array();
        var $registerStack=Array();                     // Stack used for storing array and retrieving register arrays (see LOAD_REGISTER and CLEAR_REGISTER)
        var $cObjectDepthCounter = 50;          // Checking that the function is not called eternally. This is done by interrupting at a depth of 50
        var $recordRegister = Array();          // used by cObj->RECORDS and cObj->CONTENT to ensure the a records is NOT rendered twice through it!
        var $currentRecord = '';                        // This is set to the [table]:[uid] of the latest record rendered. Note that class tslib_cObj has an equal value, but that is pointing to the record delivered in the $data-array of the tslib_cObj instance, if the cObjects CONTENT or RECORD created that instance
        var $accessKey =array();                        // Used by class tslib_menu to keep track of access-keys.
        var $imagesOnPage=array();                      // Numerical array where image filenames are added if they are referenced in the rendered document. This includes only TYPO3 generated/inserted images.
        var $lastImageInfo=array();                     // Is set in tslib_cObj->cImage() function to the info-array of the most recent rendered image. The information is used in tslib_cObj->IMGTEXT
        var $uniqueCounter=0;                           // Used to generate page-unique keys. Point is that uniqid() functions is very slow, so a unikey key is made based on this, see function uniqueHash()
        var $uniqueString='';
        var $indexedDocTitle='';                        // This value will be used as the title for the page in the indexer (if indexing happens)
        var $altPageTitle='';                           // Alternative page title (normally the title of the page record). Can be set from applications you make.
        var $pEncAllowedParamNames=array();     // An array that holds parameter names (keys) of GET parameters which MAY be MD5/base64 encoded with simulate_static_documents method.
        var $baseUrl='';                                        // The base URL set for the page header.
        var $anchorPrefix='';                           // The proper anchor prefix needed when using speaking urls. (only set if baseUrl is set)

                // Page content render object
        var $cObj ='';                                          // is instantiated object of tslib_cObj

                // CONTENT accumulation
        var $content='';                                        // All page content is accumulated in this variable. See pagegen.php

                // GENERAL
        var $clientInfo='';                                     // Set to the browser: net / msie if 4+ browsers
        var $scriptParseTime=0;
        var $TCAloaded = 0;                                     // Set ONLY if the full TCA is loaded

                // Character set (charset) conversion object:
        var $csConvObj;                                         // An instance of the "t3lib_cs" class. May be used by any application.
        var $defaultCharSet = 'iso-8859-1';     // The default charset used in the frontend if nothing else is set.
        var $renderCharset='';                          // Internal charset of the frontend during rendering: Defaults to "forceCharset" and if that is not set, to ->defaultCharSet
        var $metaCharset='';                            // Output charset of the websites content. This is the charset found in the header, meta tag etc. If different from $renderCharset a conversion happens before output to browser. Defaults to ->renderCharset if not set.
        var $localeCharset='';                          // Assumed charset of locale strings.

                // LANG:
        var $lang='';                                           // Set to the system language key (used on the site)
        var $langSplitIndex=0;                          // Set to the index number of the language key
        var $labelsCharset='';                          // Charset of the labels from locallang (based on $this->lang)
        var $convCharsetToFrom='';                      // Set to the charsets to convert from/to IF there are any difference. Otherwise this stays a string
        var $LL_labels_cache=array();
        var $LL_files_cache=array();





        function tslib_fe($TYPO3_CONF_VARS, $id, $type, $no_cache='', $cHash='', $jumpurl='',$MP='',$RDCT='')   {

                        // Setting some variables:
                $this->TYPO3_CONF_VARS = $TYPO3_CONF_VARS;
                $this->id = $id;
                $this->type = $type;
                $this->no_cache = $no_cache ? 1 : 0;
                $this->cHash = $cHash;
                $this->jumpurl = $jumpurl;
                $this->MP = $this->TYPO3_CONF_VARS['FE']['enable_mount_pids'] ? (string)$MP : '';
                $this->RDCT = $RDCT;
                $this->clientInfo = t3lib_div::clientInfo();
                $this->uniqueString=md5(microtime());

                $this->csConvObj = t3lib_div::makeInstance('t3lib_cs');

                        // Call post processing function for constructor:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['tslib_fe-PostProc']))    {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['tslib_fe-PostProc'] as $_funcRef)     {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }
        }

        function connectToMySQL()       {
                $this->connectToDB();
        }

        function connectToDB()  {
                if ($GLOBALS['TYPO3_DB']->sql_pconnect(TYPO3_db_host, TYPO3_db_username, TYPO3_db_password))    {
                        if (!TYPO3_db)  {
                                $this->printError('No database selected','Database Error');
                                        // Redirects to the Install Tool:
                                echo '<script type="text/javascript">
                                                /*<![CDATA[*/
                                        window.location.href = "'.TYPO3_mainDir.'install/index.php?mode=123&step=1&password=joh316";
                                                /*]]>*/
                                        </script>';
                                exit;
                        } elseif (!$GLOBALS['TYPO3_DB']->sql_select_db(TYPO3_db))       {
                                $this->printError('Cannot connect to the current database, "'.TYPO3_db.'"','Database Error');
                                exit;
                        }
                } else {
                        if (!TYPO3_db)  {
                                        // Redirects to the Install Tool:
                                echo '<script type="text/javascript">
                                                /*<![CDATA[*/
                                        window.location.href = "'.TYPO3_mainDir.'install/index.php?mode=123&step=1&password=joh316";
                                                /*]]>*/
                                        </script>';
                                exit;
                        }
                        $this->printError('The current username, password or host was not accepted when the connection to the database was attempted to be established!','Database Error');
                        exit;
                }


                        // Call post processing function for DB connection:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['connectToDB']))  {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['connectToDB'] as $_funcRef)   {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }
        }

        function sendRedirect() {
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('params', 'cache_md5params', 'md5hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($this->RDCT, 'cache_md5params'));
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                        $this->updateMD5paramsRecord($this->RDCT);
                        header('Location: '.$row['params']);
                        exit;
                }
        }


















        /********************************************
         *
         * Initializing, resolving page id
         *
         ********************************************/


        function initFEuser()   {
                $this->fe_user = t3lib_div::makeInstance('tslib_feUserAuth');

                $this->fe_user->lockIP = $this->TYPO3_CONF_VARS['FE']['lockIP'];
                $this->fe_user->lockHashKeyWords = $this->TYPO3_CONF_VARS['FE']['lockHashKeyWords'];
                $this->fe_user->checkPid = $this->TYPO3_CONF_VARS['FE']['checkFeUserPid'];
                $this->fe_user->lifetime = intval($this->TYPO3_CONF_VARS['FE']['lifetime']);
                $this->fe_user->checkPid_value = $GLOBALS['TYPO3_DB']->cleanIntList(t3lib_div::_GP('pid'));     // List of pid's acceptable

                        // Check if a session is transferred:
                if (t3lib_div::_GP('FE_SESSION_KEY'))   {
                        $fe_sParts = explode('-',t3lib_div::_GP('FE_SESSION_KEY'));
                        if (!strcmp(md5($fe_sParts[0].'/'.$this->TYPO3_CONF_VARS['SYS']['encryptionKey']), $fe_sParts[1]))      {       // If the session key hash check is OK:
                                $_COOKIE[$this->fe_user->name] = $fe_sParts[0];
                                $this->fe_user->forceSetCookie = 1;
                        }
                }

                if ($this->TYPO3_CONF_VARS['FE']['dontSetCookie'])      {
                        $this->fe_user->dontSetCookie=1;
                }

                $this->fe_user->start();
                $this->fe_user->unpack_uc('');
                $this->fe_user->fetchSessionData();     // Gets session data
                $recs = t3lib_div::_GP('recs');
                if (is_array($recs))    {       // If any record registration is submitted, register the record.
                        $this->fe_user->record_registration($recs, $this->TYPO3_CONF_VARS['FE']['maxSessionDataSize']);
                }

                        // Call hook for possible manipulation of frontend user object
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['initFEuser']))   {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['initFEuser'] as $_funcRef)    {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }

                        // For every 60 seconds the is_online timestamp is updated.
                if (is_array($this->fe_user->user) && $this->fe_user->user['uid'] && $this->fe_user->user['is_online']<($GLOBALS['EXEC_TIME']-60))      {
                        $GLOBALS['TYPO3_DB']->exec_UPDATEquery('fe_users', 'uid='.intval($this->fe_user->user['uid']), array('is_online' => $GLOBALS['EXEC_TIME']));
                }
        }

        function initUserGroups() {

                $this->fe_user->showHiddenRecords = $this->showHiddenRecords;           // This affects the hidden-flag selecting the fe_groups for the user!
                $this->fe_user->fetchGroupData();       // no matter if we have an active user we try to fetch matching groups which can be set without an user (simulation for instance!)

                if (is_array($this->fe_user->user) && count($this->fe_user->groupData['uid']))  {
                        $this->loginUser=1;     // global flag!
                        $this->gr_list = '0,-2';        // group -2 is not an existing group, but denotes a 'default' group when a user IS logged in. This is used to let elements be shown for all logged in users!
                        $gr_array = $this->fe_user->groupData['uid'];
                } else {
                        $this->loginUser=0;
                        $this->gr_list = '0,-1';        // group -1 is not an existing group, but denotes a 'default' group when not logged in. This is used to let elements be hidden, when a user is logged in!

                        if ($this->loginAllowedInBranch)        {
                                $gr_array = $this->fe_user->groupData['uid'];   // For cases where logins are not banned from a branch usergroups can be set based on IP masks so we should add the usergroups uids.
                        } else {
                                $gr_array = array();            // Set to blank since we will NOT risk any groups being set when no logins are allowed!
                        }
                }

                        // Clean up.
                $gr_array = array_unique($gr_array);    // Make unique...
                sort($gr_array);        // sort
                if (count($gr_array))   {
                        $this->gr_list.=','.implode(',',$gr_array);
                }

                if ($this->fe_user->writeDevLog)        t3lib_div::devLog('Valid usergroups for TSFE: '.$this->gr_list, 'tslib_fe');
        }

        function isUserOrGroupSet()     {
                return is_array($this->fe_user->user) || $this->gr_list!=='0,-1';
        }

        function checkAlternativeIdMethods()    {

                $this->siteScript = t3lib_div::getIndpEnv('TYPO3_SITE_SCRIPT');

                        // Resolving of "simulateStaticDocuments" URLs:
                if ($this->siteScript && substr($this->siteScript,0,9)!='index.php')    {               // If there has been a redirect (basically; we arrived here otherwise than via "index.php" in the URL) this can happend either due to a CGI-script or because of reWrite rule. Earlier we used $_SERVER['REDIRECT_URL'] to check but
                        $uParts = parse_url($this->siteScript); // Parse the path:
                        $fI = t3lib_div::split_fileref($uParts['path']);

                        if (!$fI['path'] && $fI['file'] && substr($fI['file'],-5)=='.html')     {
                                $parts = explode('.',$fI['file']);
                                $pCount = count($parts);
                                if ($pCount>2)  {
                                        $this->type = intval($parts[$pCount-2]);
                                        $this->id = $parts[$pCount-3];
                                } else {
                                        $this->type = 0;
                                        $this->id = $parts[0];
                                }
                        }
                }

                        // If PATH_INFO
                if (t3lib_div::getIndpEnv('PATH_INFO')) {               // If pathinfo contains stuff...
                        $parts=t3lib_div::trimExplode('/',t3lib_div::getIndpEnv('PATH_INFO'),1);
                        $parts[]='html';
                        $pCount = count($parts);
                        if ($pCount>2)  {
                                $this->type = intval($parts[$pCount-2]);
                                $this->id = $parts[$pCount-3];
                        } else {
                                $this->type = 0;
                                $this->id = $parts[0];
                        }
                        $this->absRefPrefix_force=1;
                }

                        // Call post processing function for custom URL methods.
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['checkAlternativeIdMethods-PostProc']))   {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['checkAlternativeIdMethods-PostProc'] as $_funcRef)    {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }
        }

        function clear_preview()        {
                $this->showHiddenPage = 0;
                $this->showHiddenRecords = 0;
                $GLOBALS['SIM_EXEC_TIME'] = $GLOBALS['EXEC_TIME'];
                $this->fePreview = 0;
        }

        function determineId()  {

                        // Getting ARG-v values if some
                $this->setIDfromArgV();

                        // If there is a Backend login we are going to check for any preview settings:
                $GLOBALS['TT']->push('beUserLogin','');
                if ($this->beUserLogin || $this->doWorkspacePreview())  {

                                // Backend user preview features:
                        if ($this->beUserLogin) {
                                $this->fePreview = $GLOBALS['BE_USER']->extGetFeAdminValue('preview') ? 1 : 0;

                                        // If admin panel preview is enabled...
                                if ($this->fePreview)   {
                                        $fe_user_OLD_USERGROUP = $this->fe_user->user['usergroup'];

                                        $this->showHiddenPage = $GLOBALS['BE_USER']->extGetFeAdminValue('preview','showHiddenPages');
                                        $this->showHiddenRecords = $GLOBALS['BE_USER']->extGetFeAdminValue('preview','showHiddenRecords');
                                                // simulate date
                                        $simTime = $GLOBALS['BE_USER']->extGetFeAdminValue('preview','simulateDate');
                                        if ($simTime)   $GLOBALS['SIM_EXEC_TIME']=$simTime;
                                                // simulate user
                                        $simUserGroup = $GLOBALS['BE_USER']->extGetFeAdminValue('preview','simulateUserGroup');
                                        $this->simUserGroup = $simUserGroup;
                                        if ($simUserGroup)      $this->fe_user->user['usergroup']=$simUserGroup;
                                        if (!$simUserGroup && !$simTime && !$this->showHiddenPage && !$this->showHiddenRecords) {
                                                $this->fePreview=0;
                                        }
                                }
                        }

                        if ($this->id)  {

                                        // Now it's investigated if the raw page-id points to a hidden page and if so, the flag is set.
                                        // This does not require the preview flag to be set in the admin panel
                                $idQ = t3lib_div::testInt($this->id) ? 'uid='.intval($this->id) : 'alias='.$GLOBALS['TYPO3_DB']->fullQuoteStr($this->id, 'pages').' AND pid>=0';        // pid>=0 added for the sake of versioning...
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('hidden', 'pages', $idQ.' AND hidden!=0 AND deleted=0');
                                if ($GLOBALS['TYPO3_DB']->sql_num_rows($res))   {
                                        $this->fePreview = 1;   // The preview flag is set only if the current page turns out to actually be hidden!
                                        $this->showHiddenPage = 1;
                                }

                                        // For Live workspace: Check root line for proper connection to tree root (done because of possible preview of page / branch versions)
                                if (!$this->fePreview && $this->whichWorkspace()===0)   {

                                                // Initialize the page-select functions to check rootline:
                                        $temp_sys_page = t3lib_div::makeInstance('t3lib_pageSelect');
                                        $temp_sys_page->init($this->showHiddenPage);

                                                // If root line contained NO records and ->error_getRootLine_failPid tells us that it was because of a pid=-1 (indicating a "version" record)...:
                                        if (!count($temp_sys_page->getRootLine($this->id,$this->MP)) && $temp_sys_page->error_getRootLine_failPid==-1)  {

                                                        // Setting versioningPreview flag and try again:
                                                $temp_sys_page->versioningPreview = TRUE;
                                                if (count($temp_sys_page->getRootLine($this->id,$this->MP)))    {
                                                                // Finally, we got a root line (meaning that it WAS due to versioning preview of a page somewhere) and we set the fePreview flag which in itself will allow sys_page class to display previews of versionized records.
                                                        $this->fePreview = 1;
                                                }
                                        }
                                }
                        }

                                // The preview flag will be set if a backend user is in an offline workspace
                        if (($GLOBALS['BE_USER']->user['workspace_preview'] || t3lib_div::_GP('ADMCMD_view') || $this->doWorkspacePreview()) && ($this->whichWorkspace()===-1 || $this->whichWorkspace()>0))    {
                                $this->fePreview = 2;   // Will show special preview message.
                        }

                                // If the front-end is showing a preview, caching MUST be disabled.
                        if ($this->fePreview)   {
                                $this->set_no_cache();
                        }
                }
                $GLOBALS['TT']->pull();

                        // Now, get the id, validate access etc:
                $this->fetch_the_id();

                        // Check if backend user has read access to this page. If not, recalculate the id.
                if ($this->beUserLogin && $this->fePreview)     {
                        if (!$GLOBALS['BE_USER']->doesUserHaveAccess($this->page,1))    {

                                        // Resetting
                                $this->clear_preview();
                                $this->fe_user->user['usergroup'] = $fe_user_OLD_USERGROUP;

                                        // Fetching the id again, now with the preview settings reset.
                                $this->fetch_the_id();
                        }
                }

                        // Checks if user logins are blocked for a certain branch and if so, will unset user login and re-fetch ID.
                $this->loginAllowedInBranch = $this->checkIfLoginAllowedInBranch();
                if (!$this->loginAllowedInBranch)       {       // Logins are not allowed:
                        if ($this->isUserOrGroupSet())  {       // Only if there is a login will we run this...

                                        // Clear out user and group:
                                unset($this->fe_user->user);
                                $this->gr_list = '0,-1';

                                        // Fetching the id again, now with the preview settings reset.
                                $this->fetch_the_id();
                        }
                }

                        // Final cleaning.
                $this->id = $this->contentPid = intval($this->id);      // Make sure it's an integer
                $this->type = intval($this->type);      // Make sure it's an integer

                        // Look for alternative content PID if page is under version preview:
                if ($this->fePreview)   {
                        if ($this->page['_ORIG_pid']==-1 && $this->page['t3ver_swapmode']==0)   {       // Current page must have been an offline version and have swapmode set to 0:
                                        // Setting contentPid here for preview might not be completely correct to do. Strictly the "_ORIG_uid" value should be used for tables where "versioning_followPages" is set and for others not. However this is a working quick-fix to display content elements at least!
                                $this->contentPid = $this->page['_ORIG_uid'];
                        }
                }

                        // Call post processing function for id determination:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['determineId-PostProc'])) {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['determineId-PostProc'] as $_funcRef)  {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }
        }

        function fetch_the_id() {
                $GLOBALS['TT']->push('fetch_the_id initialize/','');

                        // Initialize the page-select functions.
                $this->sys_page = t3lib_div::makeInstance('t3lib_pageSelect');
                $this->sys_page->versioningPreview = $this->fePreview ? TRUE : FALSE;
                $this->sys_page->versioningWorkspaceId = $this->whichWorkspace();
                $this->sys_page->init($this->showHiddenPage);

                        // Set the valid usergroups for FE
                $this->initUserGroups();

                        // Sets sys_page where-clause
                $this->setSysPageWhereClause();

                        // Splitting $this->id by a period (.). First part is 'id' and second part - if exists - will overrule the &type param if given
                $pParts = explode('.',$this->id);
                $this->id = $pParts[0]; // Set it.
                if (isset($pParts[1]))  {$this->type=$pParts[1];}

                        // Splitting $this->id by a comma (,). First part is 'id' and other parts are just stored for use in scripts.
                $this->idParts = explode(',',$this->id);

                        // Splitting by a '+' sign - used for base64/md5 methods of parameter encryption for simulate static documents.
                list($pgID,$SSD_p)=explode('+',$this->idParts[0],2);
                if ($SSD_p)     {       $this->idPartsAnalyze($SSD_p);  }
                $this->id = $pgID;      // Set id

                        // If $this->id is a string, it's an alias
                $this->checkAndSetAlias();

                        // The id and type is set to the integer-value - just to be sure...
                $this->id = intval($this->id);
                $this->type = intval($this->type);
                $GLOBALS['TT']->pull();

                        // We find the first page belonging to the current domain
                $GLOBALS['TT']->push('fetch_the_id domain/','');
                $this->domainStartPage = $this->findDomainRecord($this->TYPO3_CONF_VARS['SYS']['recursiveDomainSearch']);       // the page_id of the current domain
                if (!$this->id) {
                        if ($this->domainStartPage)     {
                                $this->id = $this->domainStartPage;     // If the id was not previously set, set it to the id of the domain.
                        } else {
                                $theFirstPage = $this->sys_page->getFirstWebPage($this->id);    // Find the first 'visible' page in that domain
                                if ($theFirstPage)      {
                                        $this->id = $theFirstPage['uid'];
                                } else {
                                        $this->printError('No pages are found on the rootlevel!');
                                        exit;
                                }
                        }
                }
                $GLOBALS['TT']->pull();

                $GLOBALS['TT']->push('fetch_the_id rootLine/','');
                $requestedId = $this->id;               // We store the originally requested id
                $this->getPageAndRootlineWithDomain($this->domainStartPage);
                $GLOBALS['TT']->pull();

                if ($this->pageNotFound && $this->TYPO3_CONF_VARS['FE']['pageNotFound_handling'])       {
                        $pNotFoundMsg = array(
                                1 => 'ID was not an accessible page',
                                2 => 'Subsection was found and not accessible',
                                3 => 'ID was outside the domain',
                                4 => 'The requested page alias does not exist'
                        );
                        $this->pageNotFoundAndExit($pNotFoundMsg[$this->pageNotFound]);
                }

                        // set no_cache if set
                if ($this->page['no_cache'])    {
                        $this->set_no_cache();
                }

                        // Init SYS_LASTCHANGED
                $this->register['SYS_LASTCHANGED'] = intval($this->page['tstamp']);
                if ($this->register['SYS_LASTCHANGED'] < intval($this->page['SYS_LASTCHANGED']))        {
                        $this->register['SYS_LASTCHANGED'] = intval($this->page['SYS_LASTCHANGED']);
                }
        }

        function getPageAndRootline() {
                $this->page = $this->sys_page->getPage($this->id);
                if (!count($this->page))        {
                                // If no page, we try to find the page before in the rootLine.
                        $this->pageNotFound=1;                  // Page is 'not found' in case the id itself was not an accessible page. code 1
                        $this->rootLine = $this->sys_page->getRootLine($this->id,$this->MP);
                        if (count($this->rootLine))     {
                                $c=count($this->rootLine)-1;
                                while($c>0)     {

                                                // Add to page access failure history:
                                        $this->pageAccessFailureHistory['direct_access'][] = $this->rootLine[$c];

                                                // Decrease to next page in rootline and check the access to that, if OK, set as page record and ID value.
                                        $c--;
                                        $this->id = $this->rootLine[$c]['uid'];
                                        $this->page = $this->sys_page->getPage($this->id);
                                        if (count($this->page)){ break; }
                                }
                        }
                                // If still no page...
                        if (!count($this->page))        {
                                if ($this->TYPO3_CONF_VARS['FE']['pageNotFound_handling'])      {
                                        $this->pageNotFoundAndExit('The requested page does not exist!');
                                } else {
                                        $this->printError('The requested page does not exist!');
                                        exit;
                                }
                        }
                }

                        // Spacer is not accessible in frontend
                if ($this->page['doktype'] == 199)      {
                        if ($this->TYPO3_CONF_VARS['FE']['pageNotFound_handling'])      {
                                $this->pageNotFoundAndExit('The requested page does not exist!');
                        } else {
                                $this->printError('The requested page does not exist!');
                                exit;
                        }
                }

                        // Is the ID a link to another page??
                if ($this->page['doktype']==4)  {
                        $this->MP = '';         // We need to clear MP if the page is a shortcut. Reason is if the short cut goes to another page, then we LEAVE the rootline which the MP expects.
                        $this->page = $this->getPageShortcut($this->page['shortcut'],$this->page['shortcut_mode'],$this->page['uid']);
                        $this->id = $this->page['uid'];
                }

                        // Gets the rootLine
                $this->rootLine = $this->sys_page->getRootLine($this->id,$this->MP);

                        // If not rootline we're off...
                if (!count($this->rootLine))    {
                        $this->printError('The requested page didn\'t have a proper connection to the tree-root! <br /><br />('.$this->sys_page->error_getRootLine.')');
                        exit;
                }

                        // Checking for include section regarding the hidden/starttime/endtime/fe_user (that is access control of a whole subbranch!)
                if ($this->checkRootlineForIncludeSection())    {
                        if (!count($this->rootLine))    {
                                $this->printError('The requested page was not accessible!');
                                exit;
                        } else {
                                $el = reset($this->rootLine);
                                $this->id = $el['uid'];
                                $this->page = $this->sys_page->getPage($this->id);
                                $this->rootLine = $this->sys_page->getRootLine($this->id,$this->MP);
                        }
                }
        }

        function getPageShortcut($SC,$mode,$thisUid,$itera=20,$pageLog=array()) {
                $idArray = t3lib_div::intExplode(',',$SC);

                        // Find $page record depending on shortcut mode:
                switch($mode)   {
                        case 1:
                        case 2:
                                $pageArray = $this->sys_page->getMenu($idArray[0]?$idArray[0]:$thisUid,'*','sorting','AND pages.doktype<199 AND pages.doktype!=6');
                                $pO = 0;
                                if ($mode==2 && count($pageArray))      {       // random
                                        $this->make_seed();
                                        $randval = intval(rand(0,count($pageArray)-1));
                                        $pO = $randval;
                                }
                                $c = 0;
                                reset($pageArray);
                                while(list(,$pV)=each($pageArray))      {
                                        if ($c==$pO)    {
                                                $page = $pV;
                                                break;
                                        }
                                        $c++;
                                }
                        break;
                        default:
                                $page = $this->sys_page->getPage($idArray[0]);
                        break;
                }

                        // Check if short cut page was a shortcut itself, if so look up recursively:
                if ($page['doktype']==4)        {
                        if (!in_array($page['uid'],$pageLog) && $itera>0)       {
                                $pageLog[] = $page['uid'];
                                $page = $this->getPageShortcut($page['shortcut'],$page['shortcut_mode'],$page['uid'],$itera-1,$pageLog);
                        } else {
                                $pageLog[] = $page['uid'];
                                $this->printError('Page shortcuts were looping in uids '.implode(',',$pageLog).'...!');
                                exit;
                        }
                }
                        // Return resulting page:
                return $page;
        }

        function checkRootlineForIncludeSection()       {
                $c=count($this->rootLine);
                $removeTheRestFlag=0;

                for ($a=0;$a<$c;$a++)   {
                        if (!$this->checkPagerecordForIncludeSection($this->rootLine[$a]))      {
                                        // Add to page access failure history:
                                $this->pageAccessFailureHistory['sub_section'][] = $this->rootLine[$a];
                                $removeTheRestFlag=1;
                        }
                        if ($this->rootLine[$a]['doktype']==6)  {
                                if ($this->beUserLogin) {       // If there is a backend user logged in, check if he has read access to the page:
                                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid', 'pages', 'uid='.intval($this->id).' AND '.$GLOBALS['BE_USER']->getPagePermsClause(1));     // versionOL()?
                                        list($isPage) = $GLOBALS['TYPO3_DB']->sql_fetch_row($res);
                                        if (!$isPage)   $removeTheRestFlag=1;   // If there was no page selected, the user apparently did not have read access to the current PAGE (not position in rootline) and we set the remove-flag...
                                } else {        // Dont go here, if there is no backend user logged in.
                                        $removeTheRestFlag=1;
                                }
                        }
                        if ($removeTheRestFlag) {
                                $this->pageNotFound=2;                  // Page is 'not found' in case a subsection was found and not accessible, code 2
                                unset($this->rootLine[$a]);
                        }
                }
                return $removeTheRestFlag;
        }

        function checkEnableFields($row,$bypassGroupCheck=FALSE)        {
                if ((!$row['hidden'] || $this->showHiddenPage)
                        && $row['starttime']<=$GLOBALS['SIM_EXEC_TIME']
                        && ($row['endtime']==0 || $row['endtime']>$GLOBALS['SIM_EXEC_TIME'])
                        && ($bypassGroupCheck || $this->checkPageGroupAccess($row))
                ) { return TRUE; }
        }

        function checkPageGroupAccess($row, $groupList=NULL) {
                if(is_null($groupList)) {
                        $groupList = $this->gr_list;
                }
                if(!is_array($groupList)) {
                        $groupList = explode(',', $groupList);
                }
                $pageGroupList = explode(',', $row['fe_group'] ? $row['fe_group'] : 0);
                return count(array_intersect($groupList, $pageGroupList)) > 0;
        }

        function checkPagerecordForIncludeSection($row) {
                return (!$row['extendToSubpages'] || $this->checkEnableFields($row)) ? 1 : 0;
        }

        function checkIfLoginAllowedInBranch()  {

                        // Initialize:
                $c = count($this->rootLine);
                $disable = FALSE;

                        // Traverse root line from root and outwards:
                for ($a=0; $a<$c; $a++) {

                                // If a value is set for login state:
                        if ($this->rootLine[$a]['fe_login_mode'] > 0)   {

                                        // Determine state from value:
                                $disable = (int)$this->rootLine[$a]['fe_login_mode'] === 1 ? TRUE : FALSE;
                        }
                }

                return !$disable;
        }

        function getPageAccessFailureReasons()  {
                $output = array();

                $combinedRecords = array_merge(
                        is_array($this->pageAccessFailureHistory['direct_access']) ? $this->pageAccessFailureHistory['direct_access'] : array(array('fe_group'=>0)),    // Adding fake first record for direct access if none, otherwise $k==0 below will be indicating a sub-section record to be first direct_access record which is of course false!
                        is_array($this->pageAccessFailureHistory['sub_section']) ? $this->pageAccessFailureHistory['sub_section'] : array()
                );

                if (count($combinedRecords))    {
                        foreach($combinedRecords as $k => $pagerec)     {
                                // If $k=0 then it is the very first page the original ID was pointing at and that will get a full check of course
                                // If $k>0 it is parent pages being tested. They are only significant for the access to the first page IF they had the extendToSubpages flag set, hence checked only then!
                                if (!$k || $pagerec['extendToSubpages'])        {
                                        if ($pagerec['hidden']) $output['hidden'][$pagerec['uid']] = TRUE;
                                        if ($pagerec['starttime'] > $GLOBALS['SIM_EXEC_TIME'])  $output['starttime'][$pagerec['uid']] = $pagerec['starttime'];
                                        if ($pagerec['endtime']!=0 && $pagerec['endtime'] <= $GLOBALS['SIM_EXEC_TIME']) $output['endtime'][$pagerec['uid']] = $pagerec['endtime'];
                                        if (!$this->checkPageGroupAccess($pagerec))     $output['fe_group'][$pagerec['uid']] = $pagerec['fe_group'];
                                }
                        }
                }

                return $output;
        }

        function setIDfromArgV()        {
                if (!$this->id) {
                        list($theAlias) = explode('&',t3lib_div::getIndpEnv('QUERY_STRING'));
                        $theAlias = trim($theAlias);
                        $this->id = ($theAlias != '' && strpos($theAlias, '=') === false) ? $theAlias : 0;
                }
        }

        function getPageAndRootlineWithDomain($domainStartPage) {
                $this->getPageAndRootline();

                // Checks if the $domain-startpage is in the rootLine. This is necessary so that references to page-id's from other domains are not possible.
                if ($domainStartPage && is_array($this->rootLine)) {
                        reset ($this->rootLine);
                        $idFound = 0;
                        while(list($key,$val)=each($this->rootLine)) {
                                if ($val['uid']==$domainStartPage)      {
                                        $idFound=1;
                                        break;
                                }
                        }
                        if (!$idFound)  {
                                $this->pageNotFound=3;                  // Page is 'not found' in case the id was outside the domain, code 3
                                $this->id = $domainStartPage;
                                $this->getPageAndRootline();            //re-get the page and rootline if the id was not found.
                        }
                }
        }

        function setSysPageWhereClause()        {
                $this->sys_page->where_hid_del.=' AND pages.doktype<200';
                $this->sys_page->where_groupAccess = $this->sys_page->getMultipleGroupsWhereClause('pages.fe_group', 'pages');
        }

        function findDomainRecord($recursive=0) {
                if ($recursive) {
                        $host = explode('.',t3lib_div::getIndpEnv('HTTP_HOST'));
                        while(count($host))     {
                                $pageUid = $this->sys_page->getDomainStartPage(implode('.',$host),t3lib_div::getIndpEnv('SCRIPT_NAME'),t3lib_div::getIndpEnv('REQUEST_URI'));
                                if ($pageUid)   return $pageUid; else array_shift($host);
                        }
                        return $pageUid;
                } else {
                        return $this->sys_page->getDomainStartPage(t3lib_div::getIndpEnv('HTTP_HOST'),t3lib_div::getIndpEnv('SCRIPT_NAME'),t3lib_div::getIndpEnv('REQUEST_URI'));
                }
        }

        function pageNotFoundAndExit($reason='', $header='')    {
                $header = $header ? $header : $this->TYPO3_CONF_VARS['FE']['pageNotFound_handling_statheader'];
                $this->pageNotFoundHandler($this->TYPO3_CONF_VARS['FE']['pageNotFound_handling'], $header, $reason);
                exit;
        }

        function pageNotFoundHandler($code, $header='', $reason='')     {

                        // Issue header in any case:
                if ($header)    {
                        $headerArr = preg_split('/\r|\n/',$header,-1,PREG_SPLIT_NO_EMPTY);
                        foreach ($headerArr as $header) {
                                header ($header);
                        }
                }

                        // Convert $code in case it was written as a string (e.g. if edited in Install Tool)
                        // TODO: Once the Install Tool handles such data types correctly, this workaround should be removed again...
                if (!strcasecmp($code,'TRUE'))  { $code=TRUE; }

                        // Create response:
                if (gettype($code)=='boolean' || !strcmp($code,1))      {       // Simply boolean; Just shows TYPO3 error page with reason:
                        $this->printError('The page did not exist or was inaccessible.'.($reason ? ' Reason: '.htmlspecialchars($reason) : ''));
                } elseif (t3lib_div::isFirstPartOfStr($code,'USER_FUNCTION:')) {
                        $funcRef = trim(substr($code,14));
                        $params = array(
                                'currentUrl' => t3lib_div::getIndpEnv('REQUEST_URI'),
                                'reasonText' => $reason,
                                'pageAccessFailureReasons' => $this->getPageAccessFailureReasons()
                        );
                        echo t3lib_div::callUserFunction($funcRef,$params,$this);
                } elseif (t3lib_div::isFirstPartOfStr($code,'READFILE:')) {
                        $readFile = t3lib_div::getFileAbsFileName(trim(substr($code,9)));
                        if (@is_file($readFile))        {
                                $fileContent = t3lib_div::getUrl($readFile);
                                $fileContent = str_replace('###CURRENT_URL###', t3lib_div::getIndpEnv('REQUEST_URI'), $fileContent);
                                $fileContent = str_replace('###REASON###', htmlspecialchars($reason), $fileContent);
                                echo $fileContent;
                        } else {
                                $this->printError('Configuration Error: 404 page "'.$readFile.'" could not be found.');
                        }
                } elseif (t3lib_div::isFirstPartOfStr($code,'REDIRECT:')) {
                        header('Location: '.t3lib_div::locationHeaderUrl(substr($code,9)));
                        exit;
                } elseif (strlen($code))        {
                                // Check if URL is relative
                        $url_parts = parse_url($code);
                        if ($url_parts['host'] == '')   {
                                $url_parts['host'] = t3lib_div::getIndpEnv('HTTP_HOST');
                                $code = t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST') . $code;
                                $checkBaseTag = false;
                        } else {
                                $checkBaseTag = true;
                        }

                                // Check recursion
                        if ($code == t3lib_div::getIndpEnv('TYPO3_REQUEST_URL')) {
                                if ($reason == '') {
                                        $reason = 'Page cannot be found.';
                                }
                                $reason.= chr(10) . chr(10) . 'Additionally, ' . $code . ' was not found while trying to retrieve the error document.';
                                $this->printError('Reason: '.nl2br(htmlspecialchars($reason)));
                                exit();
                        }

                                // Prepare headers
                        $headerArr = array(
                                'User-agent: ' . t3lib_div::getIndpEnv('HTTP_USER_AGENT'),
                                'Referer: ' . t3lib_div::getIndpEnv('TYPO3_REQUEST_URL')
                        );
                        $res = t3lib_div::getURL($code, 1, $headerArr);

                                // Header and content are separated by an empty line
                        list($header,$content) = split("\r\n\r\n", $res, 2);
                        $content.= "\r\n";

                        if (false === $content) {
                                        // Last chance -- redirect
                                header('Location: '.t3lib_div::locationHeaderUrl($code));
                        } else {

                                $forwardHeaders = array(        // Forward these response headers to the client
                                        'Content-Type:',
                                );
                                $headerArr = preg_split('/\r|\n/',$header,-1,PREG_SPLIT_NO_EMPTY);
                                foreach ($headerArr as $header) {
                                        foreach ($forwardHeaders as $h) {
                                                if (preg_match('/^'.$h.'/', $header))   {
                                                        header ($header);
                                                }
                                        }
                                }
                                        // Put <base> if necesary
                                if ($checkBaseTag)      {

                                                // If content already has <base> tag, we do not need to do anything
                                        if (false === stristr($content, '<base '))      {

                                                        // Generate href for base tag
                                                $base = $url_parts['scheme'] . '://';
                                                if ($url_parts['user'] != '')   {
                                                        $base.= $url_parts['user'];
                                                        if ($url_parts['pass'] != '')   {
                                                                $base.= ':' . $url_parts['pass'];
                                                        }
                                                        $base.= '@';
                                                }
                                                $base.= $url_parts['host'];

                                                        // Add path portion skipping possible file name
                                                $base.= preg_replace('/(.*\/)[^\/]*/', '\1', $url_parts['path']);

                                                        // Put it into content (generate also <head> if necessary)
                                                $replacement = chr(10) . '<base href="' . htmlentities($base) . '" />' . chr(10);
                                                if (stristr($content, '<head>'))        {
                                                        $content = preg_replace('/(<head>)/i', '\1' . $replacement, $content);
                                                } else {
                                                        $content = preg_replace('/(<html[^>]*>)/i', '\1<head>' . $replacement . '</head>', $content);
                                                }
                                        }
                                }
                                echo $content;  // Output the content
                        }
                } else {
                        $this->printError($reason ? 'Reason: '.htmlspecialchars($reason) : 'Page cannot be found.');
                }
                exit();
        }

        function checkAndSetAlias()     {
                if ($this->id && !t3lib_div::testInt($this->id))        {
                        $aid = $this->sys_page->getPageIdFromAlias($this->id);
                        if ($aid)       {
                                $this->id = $aid;
                        } else {
                                $this->pageNotFound = 4;
                        }
                }
        }

        function idPartsAnalyze($str)   {
                $GET_VARS = '';
                switch(substr($str,0,2))        {
                        case 'B6':
                                $addParams = base64_decode(str_replace('_','=',str_replace('-','/',substr($str,2))));
                                parse_str($addParams,$GET_VARS);
                        break;
                        case 'M5':
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('params', 'cache_md5params', 'md5hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr(substr($str,2), 'cache_md5params'));
                                $row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);

                                $this->updateMD5paramsRecord(substr($str,2));
                                parse_str($row['params'],$GET_VARS);
                        break;
                }

                $this->mergingWithGetVars($GET_VARS);
        }

        function mergingWithGetVars($GET_VARS)  {
                if (is_array($GET_VARS))        {
                        $realGet = t3lib_div::_GET();           // Getting $_GET var, unescaped.
                        if (!is_array($realGet))        $realGet = array();

                                // Merge new values on top:
                        $realGet = t3lib_div::array_merge_recursive_overrule($realGet,$GET_VARS);

                                // Write values back to $_GET:
                        t3lib_div::_GETset($realGet);

                                // Setting these specifically (like in the init-function):
                        if (isset($GET_VARS['type']))           $this->type = intval($GET_VARS['type']);
                        if (isset($GET_VARS['cHash']))          $this->cHash = $GET_VARS['cHash'];
                        if (isset($GET_VARS['jumpurl']))        $this->jumpurl = $GET_VARS['jumpurl'];
                        if (isset($GET_VARS['MP']))                     $this->MP = $this->TYPO3_CONF_VARS['FE']['enable_mount_pids'] ? $GET_VARS['MP'] : '';

                        if (isset($GET_VARS['no_cache']) && $GET_VARS['no_cache'])      $this->set_no_cache();
                }
        }

        function ADMCMD_preview(){
                $inputCode = t3lib_div::_GP('ADMCMD_prev');

                if ($inputCode) {

                                // Look for keyword configuration record:
                        list($previewData) = $GLOBALS['TYPO3_DB']->exec_SELECTgetRows(
                                '*',
                                'sys_preview',
                                'keyword='.$GLOBALS['TYPO3_DB']->fullQuoteStr($inputCode, 'sys_preview').
                                        ' AND endtime>'.time()
                        );

                                // Get: Backend login status, Frontend login status
                                // - Make sure to remove fe/be cookies (temporarily); BE already done in ADMCMD_preview_postInit()
                        if (is_array($previewData))     {
                                if (!count(t3lib_div::_POST())) {
                                        if (t3lib_div::getIndpEnv('TYPO3_SITE_URL').'index.php?ADMCMD_prev='.$inputCode === t3lib_div::getIndpEnv('TYPO3_REQUEST_URL')) {

                                                        // Unserialize configuration:
                                                $previewConfig = unserialize($previewData['config']);

                                                        // Set GET variables:
                                                $GET_VARS = '';
                                                parse_str($previewConfig['getVars'], $GET_VARS);
                                                t3lib_div::_GETset($GET_VARS);

                                                        // Return preview keyword configuration:
                                                return $previewConfig;
                                        } else die(htmlspecialchars('Request URL did not match "'.t3lib_div::getIndpEnv('TYPO3_SITE_URL').'index.php?ADMCMD_prev='.$inputCode.'"'));    // This check is to prevent people from setting additional GET vars via realurl or other URL path based ways of passing parameters.
                                } else die('POST requests are incompatible with keyword preview.');
                        } else die('ADMCMD command could not be executed! (No keyword configuration found)');
                }
        }

        function ADMCMD_preview_postInit($previewConfig){
                if (is_array($previewConfig))   {

                                // Clear cookies:
                        unset($_COOKIE['be_typo_user']);
                        $this->ADMCMD_preview_BEUSER_uid = $previewConfig['BEUSER_uid'];

                } else die('Error in preview configuration.');
        }











        /********************************************
         *
         * Template and caching related functions.
         *
         *******************************************/

        function makeCacheHash()        {
                $GET = t3lib_div::_GET();
                if ($this->cHash && is_array($GET))     {
                        $this->cHash_array = t3lib_div::cHashParams(t3lib_div::implodeArrayForUrl('',$GET));
                        $cHash_calc = t3lib_div::shortMD5(serialize($this->cHash_array));

                        if ($cHash_calc!=$this->cHash)  {
                                if ($this->TYPO3_CONF_VARS['FE']['pageNotFoundOnCHashError']) {
                                        $this->pageNotFoundAndExit('Request parameters could not be validated (&cHash comparison failed)');
                                } else {
                                        $this->set_no_cache();
                                        $GLOBALS['TT']->setTSlogMessage('The incoming cHash "'.$this->cHash.'" and calculated cHash "'.$cHash_calc.'" did not match, so caching was disabled. The fieldlist used was "'.implode(',',array_keys($this->cHash_array)).'"',2);
                                }
                        }
                }
        }

        function reqCHash()     {
                if (!$this->cHash)      {
                        if ($this->TYPO3_CONF_VARS['FE']['pageNotFoundOnCHashError']) {
                                if ($this->tempContent) { $this->clearPageCacheContent(); }
                                $this->pageNotFoundAndExit('Request parameters could not be validated (&cHash empty)');
                        } else {
                                $this->set_no_cache();
                                $GLOBALS['TT']->setTSlogMessage('TSFE->reqCHash(): No &cHash parameter was sent for GET vars though required so caching is disabled ',2);
                        }
                }
        }

        function cHashParams($addQueryParams) {
                return t3lib_div::cHashParams($addQueryParams);
        }

        function initTemplate() {
                $this->tmpl = t3lib_div::makeInstance('t3lib_TStemplate');
                $this->tmpl->init();
                $this->tmpl->tt_track= $this->beUserLogin ? 1 : 0;
        }

        function getFromCache() {
                if (!$this->no_cache)   {
                        $this->tmpl->getCurrentPageData();

                        $cc = Array();
                        if (is_array($this->tmpl->currentPageData))     {
                                        // BE CAREFULL to change the content of the cc-array. This array is serialized and an md5-hash based on this is used for caching the page.
                                        // If this hash is not the same in here in this section and after page-generation the page will not be properly cached!

                                $cc['all'] = $this->tmpl->currentPageData['all'];
                                $cc['rowSum'] = $this->tmpl->currentPageData['rowSum'];
                                $cc['rootLine'] = $this->tmpl->currentPageData['rootLine'];             // This rootline is used with templates only (matching()-function)
                                $this->all = $this->tmpl->matching($cc);        // This array is an identification of the template. If $this->all is empty it's because the template-data is not cached, which it must be.
                                ksort($this->all);
                        }
                }

                $this->content='';      // clearing the content-variable, which will hold the pagecontent
                unset($this->config);   // Unsetting the lowlevel config
                $this->cacheContentFlag = 0;

                        // Look for page in cache only if caching is not disabled and if a shift-reload is not sent to the server.
                if ($this->all && !$this->no_cache && !$this->headerNoCache())  {

                        $this->newHash = $this->getHash();

                        $GLOBALS['TT']->push('Cache Row','');
                                if ($row = $this->getFromCache_queryRow())      {

                                        $this->config = (array)unserialize($row['cache_data']);         // Fetches the lowlevel config stored with the cached data
                                        $this->content = $row['HTML'];  // Getting the content
                                        $this->tempContent = $row['temp_content'];      // Flag for temp content
                                        $this->cacheContentFlag = 1;    // Setting flag, so we know, that some cached content is gotten.
                                        $this->cacheExpires = $row['expires'];

                                        if ($this->TYPO3_CONF_VARS['FE']['debug'] || $this->config['config']['debug'])  {
                                                $dateFormat = $GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'];
                                                $timeFormat = $GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'];

                                                $this->content.=chr(10).'<!-- Cached page generated '.date($dateFormat.' '.$timeFormat, $row['tstamp']).'. Expires '.Date($dateFormat.' '.$timeFormat, $row['expires']).' -->';
                                        }

                                }
                        $GLOBALS['TT']->pull();
                }
        }

        function getFromCache_queryRow()        {

                $GLOBALS['TT']->push('Cache Query','');
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                'S.*',
                                'cache_pages S,pages P',
                                'S.hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($this->newHash, 'cache_pages').'
                                        AND S.page_id=P.uid
                                        AND S.expires > '.intval($GLOBALS['EXEC_TIME']).'
                                        AND P.deleted=0
                                        AND P.hidden=0
                                        AND P.starttime<='.intval($GLOBALS['EXEC_TIME']).'
                                        AND (P.endtime=0 OR P.endtime>'.intval($GLOBALS['EXEC_TIME']).')'
                        );
                $GLOBALS['TT']->pull();

                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                        $this->pageCachePostProcess($row,'get');
                }
                $GLOBALS['TYPO3_DB']->sql_free_result($res);
                return $row;
        }

        function headerNoCache()        {
                $disableAcquireCacheData = FALSE;

                if ($this->beUserLogin) {
                        if (strtolower($_SERVER['HTTP_CACHE_CONTROL'])==='no-cache' || strtolower($_SERVER['HTTP_PRAGMA'])==='no-cache')        {
                                $disableAcquireCacheData = TRUE;
                        }
                }

                        // Call hook for possible by-pass of requiring of page cache (for recaching purpose)
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['headerNoCache']))        {
                        $_params = array('pObj' => &$this, 'disableAcquireCacheData' => &$disableAcquireCacheData);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['headerNoCache'] as $_funcRef) {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }

                return $disableAcquireCacheData;
        }

        function getHash()      {
                $this->hash_base = serialize(
                        array(
                                'all' => $this->all,
                                'id' => intval($this->id),
                                'type' => intval($this->type),
                                'gr_list' => (string)$this->gr_list,
                                'MP' => (string)$this->MP,
                                'cHash' => $this->cHash_array
                        )
                );

                return md5($this->hash_base);
        }

        function getConfigArray()       {
                $setStatPageName = false;

                if (!is_array($this->config) || is_array($this->config['INTincScript']) || $this->forceTemplateParsing) {       // If config is not set by the cache (which would be a major mistake somewhere) OR if INTincScripts-include-scripts have been registered, then we must parse the template in order to get it
                                $GLOBALS['TT']->push('Parse template','');

                                // Force parsing, if set?:
                        $this->tmpl->forceTemplateParsing = $this->forceTemplateParsing;

                                // Start parsing the TS template. Might return cached version.
                        $this->tmpl->start($this->rootLine);
                                $GLOBALS['TT']->pull();

                        if ($this->tmpl->loaded)        {
                                $GLOBALS['TT']->push('Setting the config-array','');
                        //      t3lib_div::print_array($this->tmpl->setup);
                                $this->sPre = $this->tmpl->setup['types.'][$this->type];        // toplevel - objArrayName
                                $this->pSetup = $this->tmpl->setup[$this->sPre.'.'];

                                if (!is_array($this->pSetup))   {
                                        $this->printError('The page is not configured! [type= '.$this->type.']['.$this->sPre.']');
                                        exit;
                                } else {
                                        $this->config['config']=Array();

                                                // Filling the config-array.
                                        if (is_array($this->tmpl->setup['config.']))    {
                                                $this->config['config'] = $this->tmpl->setup['config.'];
                                        }
                                        if (is_array($this->pSetup['config.'])) {
                                                reset($this->pSetup['config.']);
                                                while(list($theK,$theV)=each($this->pSetup['config.'])) {
                                                        $this->config['config'][$theK] = $theV;
                                                }
                                        }
                                                // if .simulateStaticDocuments was not present, the default value will rule.
                                        if (!isset($this->config['config']['simulateStaticDocuments'])) {
                                                $this->config['config']['simulateStaticDocuments'] = trim($this->TYPO3_CONF_VARS['FE']['simulateStaticDocuments']);
                                        }
                                        if ($this->config['config']['simulateStaticDocuments']) {
                                                        // Set replacement char only if it is needed
                                                $this->setSimulReplacementChar();
                                        }

                                                // Set default values for removeDefaultJS and inlineStyle2TempFile so CSS and JS are externalized if compatversion is higher than 4.0
                                        if (!isset($this->config['config']['removeDefaultJS']) && t3lib_div::compat_version('4.0'))     {
                                                $this->config['config']['removeDefaultJS'] = 'external';
                                        }
                                        if (!isset($this->config['config']['inlineStyle2TempFile']) && t3lib_div::compat_version('4.0'))        {
                                                $this->config['config']['inlineStyle2TempFile'] = 1;
                                        }

                                                        // Processing for the config_array:
                                        $this->config['rootLine'] = $this->tmpl->rootLine;
                                        $this->config['mainScript'] = trim($this->config['config']['mainScript']) ? trim($this->config['config']['mainScript']) : 'index.php';

                                                // STAT:
                                        $theLogFile = $this->TYPO3_CONF_VARS['FE']['logfile_dir'].strftime($this->config['config']['stat_apache_logfile']);
                                                // Add PATH_site left to $theLogFile if the path is not absolute yet
                                        if (!t3lib_div::isAbsPath($theLogFile)) $theLogFile = PATH_site.$theLogFile;

                                        if ($this->config['config']['stat_apache'] && $this->config['config']['stat_apache_logfile'] && !strstr($this->config['config']['stat_apache_logfile'],'/'))    {
                                                if (t3lib_div::isAllowedAbsPath($theLogFile))   {
                                                        if (!@is_file($theLogFile))     {
                                                                touch($theLogFile);     // Try to create the logfile
                                                                t3lib_div::fixPermissions($theLogFile);
                                                        }

                                                        if (@is_file($theLogFile) && @is_writable($theLogFile)) {
                                                                $this->config['stat_vars']['logFile'] = $theLogFile;
                                                                $setStatPageName = true;        // Set page name later on
                                                        } else {
                                                                $GLOBALS['TT']->setTSlogMessage('Could not set logfile path. Check filepath and permissions.',3);
                                                        }
                                                }
                                        }

                                        $this->config['FEData'] = $this->tmpl->setup['FEData'];
                                        $this->config['FEData.'] = $this->tmpl->setup['FEData.'];
                                }
                                $GLOBALS['TT']->pull();
                        } else {
                                $this->printError('No template found!');
                                exit;
                        }
                }

                        // Initialize charset settings etc.
                $this->initLLvars();

                        // We want nice names, so we need to handle the charset
                if ($setStatPageName)   {
                                // Make life easier and accept variants for utf-8
                        if (preg_match('/utf-?8/i', $this->config['config']['stat_apache_niceTitle']))  {
                                $this->config['config']['stat_apache_niceTitle'] = 'utf-8';
                        }
                        if ($this->config['config']['stat_apache_niceTitle'] == 'utf-8')        {
                                $shortTitle = $this->csConvObj->utf8_encode($this->page['title'],$this->renderCharset);
                        } elseif ($this->config['config']['stat_apache_niceTitle'])     {
                                $shortTitle = $this->csConvObj->specCharsToASCII($this->renderCharset,$this->page['title']);
                        } else {
                                $shortTitle = $this->page['title'];
                        }
                        $len = t3lib_div::intInRange($this->config['config']['stat_apache_pageLen'],1,100,30);
                        if ($this->config['config']['stat_apache_niceTitle'] == 'utf-8')        {
                                $shortTitle = rawurlencode($this->csConvObj->substr('utf-8',$shortTitle,0,$len));
                        } else {
                                $shortTitle = substr(preg_replace('/[^.[:alnum:]_-]/','_',$shortTitle),0,$len);
                        }
                        $pageName = $this->config['config']['stat_apache_pagenames'] ? $this->config['config']['stat_apache_pagenames'] : '[path][title]--[uid].html';
                        $pageName = str_replace('[title]', $shortTitle ,$pageName);
                        $pageName = str_replace('[uid]',$this->page['uid'],$pageName);
                        $pageName = str_replace('[alias]',$this->page['alias'],$pageName);
                        $pageName = str_replace('[type]',$this->type,$pageName);
                        $temp = $this->config['rootLine'];
                        array_pop($temp);
                        if ($this->config['config']['stat_apache_noRoot'])      {
                                array_shift($temp);
                        }
                        $len = t3lib_div::intInRange($this->config['config']['stat_titleLen'],1,100,20);
                        if ($this->config['config']['stat_apache_niceTitle'] == 'utf-8')        {
                                $path = '';
                                $c = count($temp);
                                for ($i=0; $i<$c; $i++) {
                                        if ($temp[$i]['uid'])   {
                                                $p = $this->csConvObj->crop('utf-8',$this->csConvObj->utf8_encode($temp[$i]['title'],$this->renderCharset),$len,"\xE2\x80\xA6");        // U+2026; HORIZONTAL ELLIPSIS
                                                $path .= '/' . rawurlencode($p);
                                        }
                                }
                        } elseif ($this->config['config']['stat_apache_niceTitle'])     {
                                $path = $this->csConvObj->specCharsToASCII($this->renderCharset,$this->sys_page->getPathFromRootline($temp,$len));
                        } else {
                                $path = $this->sys_page->getPathFromRootline($temp,$len);
                        }
                        if ($this->config['config']['stat_apache_niceTitle'] == 'utf-8')        {
                                $this->config['stat_vars']['pageName'] = str_replace('[path]', $path.'/', $pageName);
                        } else {
                                $this->config['stat_vars']['pageName'] = str_replace('[path]', preg_replace('/[^.[:alnum:]\/_-]/','_',$path.'/'), $pageName);
                        }
                }

                        // No cache
                if ($this->config['config']['no_cache'])        { $this->set_no_cache(); }              // Set $this->no_cache true if the config.no_cache value is set!

                        // Check PATH_INFO url
                if ($this->absRefPrefix_force && strcmp($this->config['config']['simulateStaticDocuments'],'PATH_INFO'))        {
                        $redirectUrl = t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR').'index.php?id='.$this->id.'&type='.$this->type;
                        if ($this->config['config']['simulateStaticDocuments_dontRedirectPathInfoError'])       {
                                $this->printError('PATH_INFO was not configured for this website, and the URL tries to find the page by PATH_INFO!<br /><br /><a href="'.htmlspecialchars($redirectUrl).'">Click here to get to the right page.</a>','Error: PATH_INFO not configured');
                        } else {
                                header('Location: '.t3lib_div::locationHeaderUrl($redirectUrl));
                        }
                        exit;
//                      $this->set_no_cache();  // Set no_cache if PATH_INFO is NOT used as simulateStaticDoc. and if absRefPrefix_force shows that such an URL has been passed along.
                }
        }














        /********************************************
         *
         * Further initialization and data processing
         * (jumpurl/submission of forms)
         *
         *******************************************/

        function getCompressedTCarray() {
                global $TCA;

                $GLOBALS['TT']->push('Get Compressed TC array');
                if (!$this->TCAloaded)  {
                                // Create hash string for storage / retrieval of cached content:
                        $tempHash = md5('tables.php:'.
                                filemtime(TYPO3_extTableDef_script ? PATH_typo3conf.TYPO3_extTableDef_script : PATH_t3lib.'stddb/tables.php').
                                (TYPO3_extTableDef_script?filemtime(PATH_typo3conf.TYPO3_extTableDef_script):'').
                                ($GLOBALS['TYPO3_LOADED_EXT']['_CACHEFILE'] ? filemtime(PATH_typo3conf.$GLOBALS['TYPO3_LOADED_EXT']['_CACHEFILE'].'_ext_tables.php') : '')
                        );
                                // Try to fetch if:
                        list($TCA,$this->TCAcachedExtras) = unserialize($this->sys_page->getHash($tempHash, 0));
                                // If no result, create it:
                        if (!is_array($TCA))    {
                                $this->includeTCA(0);
                                $newTc = Array();
                                $this->TCAcachedExtras = array();       // Collects other information

                                foreach($TCA as $key => $val)           {
                                        $newTc[$key]['ctrl'] = $val['ctrl'];
                                        $newTc[$key]['feInterface'] = $val['feInterface'];

                                                // Collect information about localization exclusion of fields:
                                        t3lib_div::loadTCA($key);
                                        if (is_array($TCA[$key]['columns']))    {
                                                $this->TCAcachedExtras[$key]['l10n_mode'] = array();
                                                foreach($TCA[$key]['columns'] as $fN => $fV)    {
                                                        if ($fV['l10n_mode'])   {
                                                                $this->TCAcachedExtras[$key]['l10n_mode'][$fN] = $fV['l10n_mode'];
                                                        }
                                                }
                                        }
                                }

                                        // Store it in cache:
                                $TCA = $newTc;
                                $this->sys_page->storeHash($tempHash, serialize(array($newTc,$this->TCAcachedExtras)), 'SHORT TC');
                        }
                }
                $GLOBALS['TT']->pull();
        }

        function includeTCA($TCAloaded=1)       {
                global $TCA, $PAGES_TYPES, $LANG_GENERAL_LABELS, $TBE_MODULES;
                if (!$this->TCAloaded)  {
                        $TCA = Array();
                        include (TYPO3_tables_script ? PATH_typo3conf.TYPO3_tables_script : PATH_t3lib.'stddb/tables.php');
                                // Extension additions
                        if ($GLOBALS['TYPO3_LOADED_EXT']['_CACHEFILE']) {
                                include(PATH_typo3conf.$GLOBALS['TYPO3_LOADED_EXT']['_CACHEFILE'].'_ext_tables.php');
                        } else {
                                include(PATH_t3lib.'stddb/load_ext_tables.php');
                        }
                                // ext-script
                        if (TYPO3_extTableDef_script)   {
                                include (PATH_typo3conf.TYPO3_extTableDef_script);
                        }

                        $this->TCAloaded = $TCAloaded;
                }
        }

        function settingLanguage()      {

                        // Get values from TypoScript:
                $this->sys_language_uid = $this->sys_language_content = intval($this->config['config']['sys_language_uid']);
                list($this->sys_language_mode,$sys_language_content) = t3lib_div::trimExplode(';', $this->config['config']['sys_language_mode']);
                $this->sys_language_contentOL = $this->config['config']['sys_language_overlay'];

                        // If sys_language_uid is set to another language than default:
                if ($this->sys_language_uid>0)  {
                                // Request the overlay record for the sys_language_uid:
                        $olRec = $this->sys_page->getPageOverlay($this->id, $this->sys_language_uid);
                        if (!count($olRec))     {

                                        // If no OL record exists and a foreign language is asked for...
                                if ($this->sys_language_uid)    {

                                                // If requested translation is not available:
                                        if (t3lib_div::hideIfNotTranslated($this->page['l18n_cfg']))    {
                                                $this->pageNotFoundAndExit('Page is not available in the requested language.');
                                        } else {
                                                switch((string)$this->sys_language_mode)        {
                                                        case 'strict':
                                                                $this->pageNotFoundAndExit('Page is not available in the requested language (strict).');
                                                        break;
                                                        case 'content_fallback':
                                                                $fallBackOrder = t3lib_div::intExplode(',', $sys_language_content);
                                                                foreach($fallBackOrder as $orderValue)  {
                                                                        if (!strcmp($orderValue,'0') || count($this->sys_page->getPageOverlay($this->id, $orderValue))) {
                                                                                $this->sys_language_content = $orderValue;      // Setting content uid (but leaving the sys_language_uid)
                                                                                break;
                                                                        }
                                                                }
                                                        break;
                                                        case 'ignore':
                                                                $this->sys_language_content = $this->sys_language_uid;
                                                        break;
                                                        default:
                                                                        // Default is that everything defaults to the default language...
                                                                $this->sys_language_uid = $this->sys_language_content = 0;
                                                        break;
                                                }
                                        }
                                }
                        } else {
                                        // Setting sys_language if an overlay record was found (which it is only if a language is used)
                                $this->page = $this->sys_page->getPageOverlay($this->page, $this->sys_language_uid);
                        }
                }

                        // Setting sys_language_uid inside sys-page:
                $this->sys_page->sys_language_uid = $this->sys_language_uid;

                        // If default translation is not available:
                if ((!$this->sys_language_uid || !$this->sys_language_content) && $this->page['l18n_cfg']&1)    {
                        $this->pageNotFoundAndExit('Page is not available in default language.');
                }

                        // Updating content of the two rootLines IF the language key is set!
                if ($this->sys_language_uid && is_array($this->tmpl->rootLine)) {
                        reset($this->tmpl->rootLine);
                        while(list($rLk)=each($this->tmpl->rootLine))   {
                                $this->tmpl->rootLine[$rLk] = $this->sys_page->getPageOverlay($this->tmpl->rootLine[$rLk]);
                        }
                }
                if ($this->sys_language_uid && is_array($this->rootLine))       {
                        reset($this->rootLine);
                        while(list($rLk)=each($this->rootLine)) {
                                $this->rootLine[$rLk] = $this->sys_page->getPageOverlay($this->rootLine[$rLk]);
                        }
                }

                        // Finding the ISO code:
                if (t3lib_extMgm::isLoaded('static_info_tables') && $this->sys_language_content)        {       // using sys_language_content because the ISO code only (currently) affect content selection from FlexForms - which should follow "sys_language_content"
                        $sys_language_row = $this->sys_page->getRawRecord('sys_language',$this->sys_language_content,'static_lang_isocode');
                        if (is_array($sys_language_row) && $sys_language_row['static_lang_isocode'])    {
                                $stLrow = $this->sys_page->getRawRecord('static_languages',$sys_language_row['static_lang_isocode'],'lg_iso_2');
                                $this->sys_language_isocode = $stLrow['lg_iso_2'];
                        }
                }

                        // Setting softMergeIfNotBlank:
                $table_fields = t3lib_div::trimExplode(',', $this->config['config']['sys_language_softMergeIfNotBlank'],1);
                foreach($table_fields as $TF)   {
                        list($tN,$fN) = explode(':',$TF);
                        $this->TCAcachedExtras[$tN]['l10n_mode'][$fN] = 'mergeIfNotBlank';
                }

                        // Setting softExclude:
                $table_fields = t3lib_div::trimExplode(',', $this->config['config']['sys_language_softExclude'],1);
                foreach($table_fields as $TF)   {
                        list($tN,$fN) = explode(':',$TF);
                        $this->TCAcachedExtras[$tN]['l10n_mode'][$fN] = 'exclude';
                }
        }

        function settingLocale()        {

                        // Setting locale
                if ($this->config['config']['locale_all'])      {
                        # Change by Rene Fritz, 22/10 2002
                        # there's a problem that PHP parses float values in scripts wrong if the locale LC_NUMERIC is set to something with a comma as decimal point
                        # this does not work in php 4.2.3
                        #setlocale('LC_ALL',$this->config['config']['locale_all']);
                        #setlocale('LC_NUMERIC','en_US');

                        # so we set all except LC_NUMERIC
                        setlocale(LC_COLLATE,$this->config['config']['locale_all']);
                        setlocale(LC_CTYPE,$this->config['config']['locale_all']);
                        setlocale(LC_MONETARY,$this->config['config']['locale_all']);
                        setlocale(LC_TIME,$this->config['config']['locale_all']);

                        $this->localeCharset = $this->csConvObj->get_locale_charset($this->config['config']['locale_all']);
                }
        }

        function checkDataSubmission()  {
                $ret = '';
                $formtype_db = isset($_POST['formtype_db']) || isset($_POST['formtype_db_x']);
                $formtype_mail = isset($_POST['formtype_mail']) || isset($_POST['formtype_mail_x']);
                if ($formtype_db || $formtype_mail)     {
                        $refInfo = parse_url(t3lib_div::getIndpEnv('HTTP_REFERER'));
                        if (t3lib_div::getIndpEnv('TYPO3_HOST_ONLY')==$refInfo['host'] || $this->TYPO3_CONF_VARS['SYS']['doNotCheckReferer'])   {
                                if ($this->locDataCheck($_POST['locationData']))        {
                                        if ($formtype_mail)     {
                                                $ret = 'email';
                                        } elseif ($formtype_db && is_array($_POST['data']))     {
                                                $ret = 'fe_tce';
                                        }
                                        $GLOBALS['TT']->setTSlogMessage('"Check Data Submission": Return value: '.$ret,0);
                                        return $ret;
                                }
                        } else $GLOBALS['TT']->setTSlogMessage('"Check Data Submission": HTTP_HOST and REFERER HOST did not match when processing submitted formdata!',3);
                }

                        // Hook for processing data submission to extensions:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['checkDataSubmission']))  {
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['checkDataSubmission'] as $_classRef)  {
                                $_procObj = &t3lib_div::getUserObj($_classRef);
                                $_procObj->checkDataSubmission($this);
                        }
                }
                return $ret;
        }

        function fe_tce()       {
                $fe_tce = t3lib_div::makeInstance('tslib_feTCE');
                $fe_tce->start(t3lib_div::_POST('data'),$this->config['FEData.']);
                $fe_tce->includeScripts();
        }

        function locDataCheck($locationData)    {
                $locData = explode(':',$locationData);
                if (!$locData[1] ||  $this->sys_page->checkRecord($locData[1],$locData[2],1))   {
                        if (count($this->sys_page->getPage($locData[0])))       {       // $locData[1] -check means that a record is checked only if the locationData has a value for a record else than the page.
                                return 1;
                        } else $GLOBALS['TT']->setTSlogMessage('LocationData Error: The page pointed to by location data ('.$locationData.') was not accessible.',2);
                } else $GLOBALS['TT']->setTSlogMessage('LocationData Error: Location data ('.$locationData.') record pointed to was not accessible.',2);
        }

        function sendFormmail() {
                $formmail = t3lib_div::makeInstance('t3lib_formmail');

                $EMAIL_VARS = t3lib_div::_POST();
                $locationData = $EMAIL_VARS['locationData'];
                unset($EMAIL_VARS['locationData']);
                unset($EMAIL_VARS['formtype_mail'], $EMAIL_VARS['formtype_mail_x'], $EMAIL_VARS['formtype_mail_y']);

                $integrityCheck = $this->TYPO3_CONF_VARS['FE']['strictFormmail'];

                if (!$this->TYPO3_CONF_VARS['FE']['secureFormmail'])    {
                                // Check recipient field:
                        $encodedFields = explode(',','recipient,recipient_copy');       // These two fields are the ones which contain recipient addresses that can be misused to send mail from foreign servers.
                        foreach ($encodedFields as $fieldKey)   {
                                if (strlen($EMAIL_VARS[$fieldKey]))     {
                                        if ($res = $this->codeString($EMAIL_VARS[$fieldKey], TRUE))     {       // Decode...
                                                $EMAIL_VARS[$fieldKey] = $res;  // Set value if OK
                                        } elseif ($integrityCheck)      {       // Otherwise abort:
                                                $GLOBALS['TT']->setTSlogMessage('"Formmail" discovered a field ('.$fieldKey.') which could not be decoded to a valid string. Sending formmail aborted due to security reasons!',3);
                                                return false;
                                        } else {
                                                $GLOBALS['TT']->setTSlogMessage('"Formmail" discovered a field ('.$fieldKey.') which could not be decoded to a valid string. The security level accepts this, but you should consider a correct coding though!',2);
                                        }
                                }
                        }
                } else  {
                        $locData = explode(':',$locationData);
                        $record = $this->sys_page->checkRecord($locData[1],$locData[2],1);
                        $EMAIL_VARS['recipient'] = $record['subheader'];
                        $EMAIL_VARS['recipient_copy'] = $this->extractRecipientCopy($record['bodytext']);
                }

                        // Hook for preprocessing of the content for formmails:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['sendFormmail-PreProcClass']))    {
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['sendFormmail-PreProcClass'] as $_classRef)    {
                                $_procObj = &t3lib_div::getUserObj($_classRef);
                                $EMAIL_VARS = $_procObj->sendFormmail_preProcessVariables($EMAIL_VARS,$this);
                        }
                }

                $formmail->start($EMAIL_VARS);
                $formmail->sendtheMail();
                $GLOBALS['TT']->setTSlogMessage('"Formmail" invoked, sending mail to '.$EMAIL_VARS['recipient'],0);
        }

        function extractRecipientCopy($bodytext) {
                $recipient_copy = '';
                $fdef = array();
                //|recipient_copy=hidden|karsten@localhost.localdomain
                preg_match('/^[\s]*\|[\s]*recipient_copy[\s]*=[\s]*hidden[\s]*\|(.*)$/m', $bodytext, $fdef);
                $recipient_copy = (!empty($fdef[1])) ? $fdef[1] : '';
                return $recipient_copy;
        }

        function setExternalJumpUrl()   {
                if ($extUrl = $this->sys_page->getExtURL($this->page, $this->config['config']['disablePageExternalUrl']))       {
                        $this->jumpurl = $extUrl;
                }
        }

        function checkJumpUrlReferer()  {
                if (strcmp($this->jumpurl,'') && !$this->TYPO3_CONF_VARS['SYS']['doNotCheckReferer']) {
                        $referer = parse_url(t3lib_div::getIndpEnv('HTTP_REFERER'));
                        if (isset($referer['host']) && !($referer['host'] == t3lib_div::getIndpEnv('TYPO3_HOST_ONLY'))) {
                                unset($this->jumpurl);
                        }
                }
        }

        function jumpUrl()      {
                if ($this->jumpurl)     {
                        if (t3lib_div::_GP('juSecure')) {
                                $hArr = array(
                                        $this->jumpurl,
                                        t3lib_div::_GP('locationData'),
                                        $this->TYPO3_CONF_VARS['SYS']['encryptionKey']
                                );
                                $calcJuHash=t3lib_div::shortMD5(serialize($hArr));
                                $locationData = t3lib_div::_GP('locationData');
                                $juHash = t3lib_div::_GP('juHash');
                                if ($juHash == $calcJuHash)     {
                                        if ($this->locDataCheck($locationData)) {
                                                $this->jumpurl = rawurldecode($this->jumpurl);  // 211002 - goes with cObj->filelink() rawurlencode() of filenames so spaces can be allowed.
                                                if (@is_file($this->jumpurl))   {
                                                        $mimeType = t3lib_div::_GP('mimeType');
                                                        $mimeType = $mimeType ? $mimeType : 'application/octet-stream';
                                                        header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
                                                        header('Content-Type: '.$mimeType);
                                                        header('Content-Disposition: attachment; filename='.basename($this->jumpurl));
                                                        readfile($this->jumpurl);
                                                        exit;
                                                } else die('jumpurl Secure: "'.$this->jumpurl.'" was not a valid file!');
                                        } else die('jumpurl Secure: locationData, '.$locationData.', was not accessible.');
                                } else die('jumpurl Secure: Calculated juHash, '.$calcJuHash.', did not match the submitted juHash.');
                        } else {
                                $TSConf = $this->getPagesTSconfig();
                                if ($TSConf['TSFE.']['jumpUrl_transferSession'])        {
                                        $uParts = parse_url($this->jumpurl);
                                        $params = '&FE_SESSION_KEY='.rawurlencode($this->fe_user->id.'-'.md5($this->fe_user->id.'/'.$this->TYPO3_CONF_VARS['SYS']['encryptionKey']));
                                        $this->jumpurl.= ($uParts['query']?'':'?').$params;     // Add the session parameter ...
                                }
                                header('Location: '.$this->jumpurl);
                                exit;
                        }
                }
        }

        function setUrlIdToken()        {
                if ($this->config['config']['ftu'])     {
                        $this->getMethodUrlIdToken = $this->TYPO3_CONF_VARS['FE']['get_url_id_token'];
                } else {
                        $this->getMethodUrlIdToken = '';
                }
        }
























        /********************************************
         *
         * Page generation; cache handling
         *
         *******************************************/

        function isGeneratePage()       {
                return (!$this->cacheContentFlag && !$this->jumpurl);
        }

        function tempPageCacheContent() {
                $this->tempContent = false;

                if (!$this->no_cache)   {
                        $seconds = 30;
                        $title = htmlspecialchars($this->tmpl->printTitle($this->page['title']));
                        $request_uri = htmlspecialchars(t3lib_div::getIndpEnv('REQUEST_URI'));

                        $stdMsg = '
                <strong>Page is being generated.</strong><br />
                If this message does not disappear within '.$seconds.' seconds, please reload.';

                        $message = $this->config['config']['message_page_is_being_generated'];
                        if (strcmp('', $message))       {
                                $message = $this->csConvObj->utf8_encode($message,$this->renderCharset);        // This page is always encoded as UTF-8
                                $message = str_replace('###TITLE###', $title, $message);
                                $message = str_replace('###REQUEST_URI###', $request_uri, $message);
                        } else $message = $stdMsg;

                        $temp_content = '<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
        <head>
                <title>'.$title.'</title>
                <meta http-equiv="refresh" content="10" />
        </head>
        <body style="background-color:white; font-family:Verdana,Arial,Helvetica,sans-serif; color:#cccccc; text-align:center;">'.
                $message.'
        </body>
</html>';

                                // Fix 'nice errors' feature in modern browsers
                        $padSuffix = '<!--pad-->';      // prevent any trims
                        $padSize = 768 - strlen($padSuffix) - strlen($temp_content);
                        if ($padSize > 0) {
                                $temp_content = str_pad($temp_content, $padSize, "\n") . $padSuffix;
                        }

                        if (!$this->headerNoCache() && $cachedRow = $this->getFromCache_queryRow())     {
                                        // We are here because between checking for cached content earlier and now some other HTTP-process managed to store something in cache AND it was not due to a shift-reload by-pass.
                                        // This is either the "Page is being generated" screen or it can be the final result.
                                        // In any case we should not begin another rendering process also, so we silently disable caching and render the page ourselves and thats it.
                                        // Actually $cachedRow contains content that we could show instead of rendering. Maybe we should do that to gain more performance but then we should set all the stuff done in $this->getFromCache()... For now we stick to this...
                                $this->set_no_cache();
                        } else {
                                $this->tempContent = TRUE;              // This flag shows that temporary content is put in the cache
                                $this->setPageCacheContent($temp_content, $this->config, $GLOBALS['EXEC_TIME']+$seconds);
                        }
                }
        }

        function realPageCacheContent() {
                $cache_timeout = $this->page['cache_timeout'] ? $this->page['cache_timeout'] : ($this->cacheTimeOutDefault ? $this->cacheTimeOutDefault : 60*60*24);            // seconds until a cached page is too old
                $timeOutTime = $GLOBALS['EXEC_TIME']+$cache_timeout;
                if ($this->config['config']['cache_clearAtMidnight'])   {
                        $midnightTime = mktime (0,0,0,date('m',$timeOutTime),date('d',$timeOutTime),date('Y',$timeOutTime));
                        if ($midnightTime > $GLOBALS['EXEC_TIME'])      {               // If the midnight time of the expire-day is greater than the current time, we may set the timeOutTime to the new midnighttime.
                                $timeOutTime = $midnightTime;
                        }
                }
                $this->tempContent = false;
                $this->setPageCacheContent($this->content, $this->config, $timeOutTime);

                        // Hook for cache post processing (eg. writing static files!)
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['insertPageIncache']))    {
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['insertPageIncache'] as $_classRef)    {
                                $_procObj = &t3lib_div::getUserObj($_classRef);
                                $_procObj->insertPageIncache($this,$timeOutTime);
                        }
                }
        }

        function setPageCacheContent($content,$data,$tstamp)    {
                $this->clearPageCacheContent();
                $insertFields = array(
                        'hash' => $this->newHash,
                        'page_id' => $this->id,
                        'HTML' => $content,
                        'temp_content' => $this->tempContent,
                        'cache_data' => serialize($data),
                        'expires' => $tstamp,
                        'tstamp' => $GLOBALS['EXEC_TIME']
                );

                $this->cacheExpires = $tstamp;

                if ($this->page_cache_reg1)     {
                        $insertFields['reg1'] = intval($this->page_cache_reg1);
                }
                $this->pageCachePostProcess($insertFields,'set');

                $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_pages', $insertFields);
        }

        function clearPageCacheContent()        {
                $GLOBALS['TYPO3_DB']->exec_DELETEquery('cache_pages', 'hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($this->newHash, 'cache_pages'));
        }

        function clearPageCacheContent_pidList($pidList)        {
                $GLOBALS['TYPO3_DB']->exec_DELETEquery('cache_pages', 'page_id IN ('.$GLOBALS['TYPO3_DB']->cleanIntList($pidList).')');
        }

        function pageCachePostProcess(&$row,$type)      {

                if ($this->TYPO3_CONF_VARS['FE']['pageCacheToExternalFiles'])   {
                        $cacheFileName = PATH_site.'typo3temp/cache_pages/'.$row['hash']{0}.$row['hash']{1}.'/'.$row['hash'].'.html';
                        switch((string)$type)   {
                                case 'get':
                                        $row['HTML'] = @is_file($cacheFileName) ? t3lib_div::getUrl($cacheFileName) : '<!-- CACHING ERROR, sorry -->';
                                break;
                                case 'set':
                                        t3lib_div::writeFileToTypo3tempDir($cacheFileName,$row['HTML']);
                                        $row['HTML'] = '';
                                break;
                        }
                }
        }

        function setSysLastChanged()    {
                if ($this->page['SYS_LASTCHANGED'] < intval($this->register['SYS_LASTCHANGED']))        {
                        $GLOBALS['TYPO3_DB']->exec_UPDATEquery('pages', 'uid='.intval($this->id), array('SYS_LASTCHANGED' => intval($this->register['SYS_LASTCHANGED'])));
                }
        }




















        /********************************************
         *
         * Page generation; rendering and inclusion
         *
         *******************************************/

        function generatePage_preProcessing()   {
                ksort($this->all);
                        // Same codeline as in getFromCache(). BUT $this->all has been set in the meantime, so we can't just skip this line and let it be set above! Keep this line!
                $this->newHash = $this->getHash();
                $this->config['hash_base'] = $this->hash_base;  // For cache management informational purposes.

                        // Here we put some temporary stuff in the cache in order to let the first hit generate the page. The temporary cache will expire after a few seconds (typ. 30) or will be cleared by the rendered page, which will also clear and rewrite the cache.
                $this->tempPageCacheContent();

                        // Setting cache_timeout_default. May be overridden by PHP include scritps.
                $this->cacheTimeOutDefault = intval($this->config['config']['cache_period']);

                        // page is generated
                $this->no_cacheBeforePageGen = $this->no_cache;
        }

        function generatePage_whichScript()     {
                if (!$this->TYPO3_CONF_VARS['FE']['noPHPscriptInclude'] && $this->config['config']['pageGenScript'])    {
                        return $this->tmpl->getFileName($this->config['config']['pageGenScript']);
                }
        }

        function generatePage_postProcessing()  {
                        // This is to ensure, that the page is NOT cached if the no_cache parameter was set before the page was generated. This is a safety precaution, as it could have been unset by some script.
                if ($this->no_cacheBeforePageGen) $this->set_no_cache();

                        // Tidy up the code, if flag...
                if ($this->TYPO3_CONF_VARS['FE']['tidy_option'] == 'all')               {
                        $GLOBALS['TT']->push('Tidy, all','');
                                $this->content = $this->tidyHTML($this->content);
                        $GLOBALS['TT']->pull();
                }

                        // XHTML-clean the code, if flag set
                if ($this->doXHTML_cleaning() == 'all')         {
                        $GLOBALS['TT']->push('XHTML clean, all','');
                                $XHTML_clean = t3lib_div::makeInstance('t3lib_parsehtml');
                                $this->content = $XHTML_clean->XHTML_clean($this->content);
                        $GLOBALS['TT']->pull();
                }

                        // Fix local anchors in links, if flag set
                if ($this->doLocalAnchorFix() == 'all')         {
                        $GLOBALS['TT']->push('Local anchor fix, all','');
                                $this->prefixLocalAnchorsWithScript();
                        $GLOBALS['TT']->pull();
                }

                        // Hook for post-processing of page content cached/non-cached:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['contentPostProc-all']))  {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['contentPostProc-all'] as $_funcRef)   {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }

                        // Processing if caching is enabled:
                if (!$this->no_cache)   {
                                        // Tidy up the code, if flag...
                        if ($this->TYPO3_CONF_VARS['FE']['tidy_option'] == 'cached')            {
                                $GLOBALS['TT']->push('Tidy, cached','');
                                        $this->content = $this->tidyHTML($this->content);
                                $GLOBALS['TT']->pull();
                        }
                                // XHTML-clean the code, if flag set
                        if ($this->doXHTML_cleaning() == 'cached')              {
                                $GLOBALS['TT']->push('XHTML clean, cached','');
                                        $XHTML_clean = t3lib_div::makeInstance('t3lib_parsehtml');
                                        $this->content = $XHTML_clean->XHTML_clean($this->content);
                                $GLOBALS['TT']->pull();
                        }
                                // Fix local anchors in links, if flag set
                        if ($this->doLocalAnchorFix() == 'cached')              {
                                $GLOBALS['TT']->push('Local anchor fix, cached','');
                                        $this->prefixLocalAnchorsWithScript();
                                $GLOBALS['TT']->pull();
                        }

                                // Hook for post-processing of page content before being cached:
                        if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['contentPostProc-cached']))       {
                                $_params = array('pObj' => &$this);
                                foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['contentPostProc-cached'] as $_funcRef)        {
                                        t3lib_div::callUserFunction($_funcRef,$_params,$this);
                                }
                        }
                }

                        // Convert char-set for output: (should be BEFORE indexing of the content (changed 22/4 2005)), because otherwise indexed search might convert from the wrong charset! One thing is that the charset mentioned in the HTML header would be wrong since the output charset (metaCharset) has not been converted to from renderCharset. And indexed search will internally convert from metaCharset to renderCharset so the content MUST be in metaCharset already!
                $this->content = $this->convOutputCharset($this->content,'mainpage');

                        // Hook for indexing pages
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['pageIndexing'])) {
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['pageIndexing'] as $_classRef) {
                                $_procObj = &t3lib_div::getUserObj($_classRef);
                                $_procObj->hook_indexContent($this);
                        }
                }

                        // Storing for cache:
                if (!$this->no_cache)   {
                        $this->realPageCacheContent();
                } elseif ($this->tempContent)   {               // If there happens to be temporary content in the cache and the cache was not cleared due to new content put in it... ($this->no_cache=0)
                        $this->clearPageCacheContent();
                        $this->tempContent = false;
                }

                        // Sets sys-last-change:
                $this->setSysLastChanged();
        }

        function INTincScript() {
                $GLOBALS['TT']->push('Split content');
                $INTiS_splitC = explode('<!--INT_SCRIPT.',$this->content);                      // Splits content with the key.
                $this->content='';
                $GLOBALS['TT']->setTSlogMessage('Parts: '.count($INTiS_splitC));
                $GLOBALS['TT']->pull();

                        // Deprecated stuff:
                $this->additionalHeaderData = is_array($this->config['INTincScript_ext']['additionalHeaderData']) ? $this->config['INTincScript_ext']['additionalHeaderData'] : array();
                $this->additionalJavaScript = $this->config['INTincScript_ext']['additionalJavaScript'];
                $this->additionalCSS = $this->config['INTincScript_ext']['additionalCSS'];
                $this->JSCode = $this->additionalHeaderData['JSCode'];
                $this->JSImgCode = $this->additionalHeaderData['JSImgCode'];
                $this->divSection='';

                $INTiS_config = $GLOBALS['TSFE']->config['INTincScript'];
                foreach($INTiS_splitC as $INTiS_c => $INTiS_cPart)      {
                        if (substr($INTiS_cPart,32,3)=='-->')   {       // If the split had a comment-end after 32 characters it's probably a split-string
                                $INTiS_key = 'INT_SCRIPT.'.substr($INTiS_cPart,0,32);
                                $GLOBALS['TT']->push('Include '.$INTiS_config[$INTiS_key]['file'],'');
                                $incContent='';
                                if (is_array($INTiS_config[$INTiS_key]))        {
                                        $INTiS_cObj = unserialize($INTiS_config[$INTiS_key]['cObj']);
                                        $INTiS_cObj->INT_include=1;
                                        switch($INTiS_config[$INTiS_key]['type'])       {
                                                case 'SCRIPT':
                                                        $incContent = $INTiS_cObj->PHP_SCRIPT($INTiS_config[$INTiS_key]['conf']);
                                                break;
                                                case 'COA':
                                                        $incContent = $INTiS_cObj->COBJ_ARRAY($INTiS_config[$INTiS_key]['conf']);
                                                break;
                                                case 'FUNC':
                                                        $incContent = $INTiS_cObj->USER($INTiS_config[$INTiS_key]['conf']);
                                                break;
                                                case 'POSTUSERFUNC':
                                                        $incContent = $INTiS_cObj->callUserFunction($INTiS_config[$INTiS_key]['postUserFunc'], $INTiS_config[$INTiS_key]['conf'], $INTiS_config[$INTiS_key]['content']);
                                                break;
                                        }
                                }
                                $this->content.= $this->convOutputCharset($incContent,'INC-'.$INTiS_c);
                                $this->content.= substr($INTiS_cPart,35);
                                $GLOBALS['TT']->pull($incContent);
                        } else {
                                $this->content.= ($INTiS_c?'<!--INT_SCRIPT.':'').$INTiS_cPart;
                        }
                }
                $GLOBALS['TT']->push('Substitute header section');
                $this->INTincScript_loadJSCode();
                $this->content = str_replace('<!--HD_'.$this->config['INTincScript_ext']['divKey'].'-->', $this->convOutputCharset(implode(chr(10),$this->additionalHeaderData),'HD'), $this->content);
                $this->content = str_replace('<!--TDS_'.$this->config['INTincScript_ext']['divKey'].'-->', $this->convOutputCharset($this->divSection,'TDS'), $this->content);
                $this->setAbsRefPrefix();
                $GLOBALS['TT']->pull();
        }

        function INTincScript_loadJSCode()      {
                if ($this->JSImgCode)   {       // If any images added, then add them to the javascript section
                        $this->additionalHeaderData['JSImgCode']='
<script type="text/javascript">
        /*<![CDATA[*/
<!--
if (version == "n3") {
'.trim($this->JSImgCode).'
}
// -->
        /*]]>*/
</script>';
                }
                if ($this->JSCode || count($this->additionalJavaScript))        {       // Add javascript
                        $this->additionalHeaderData['JSCode']='
<script type="text/javascript">
        /*<![CDATA[*/
<!--
'.implode(chr(10),$this->additionalJavaScript).'
'.trim($this->JSCode).'
// -->
        /*]]>*/
</script>';
                }
                if (count($this->additionalCSS))        {       // Add javascript
                        $this->additionalHeaderData['_CSS']='
<style type="text/css">
        /*<![CDATA[*/
<!--
'.implode(chr(10),$this->additionalCSS).'
// -->
        /*]]>*/
</style>';
                }
        }

        function isINTincScript()       {
                return  (is_array($this->config['INTincScript']) && !$this->jumpurl);
        }

        function doXHTML_cleaning()     {
                return $this->config['config']['xhtml_cleaning'];
        }

        function doLocalAnchorFix()     {
                return $this->config['config']['prefixLocalAnchors'];
        }
















        /********************************************
         *
         * Finished off; outputting, storing session data, statistics...
         *
         *******************************************/

        function isOutputting() {

                        // Initialize by status of jumpUrl:
                $enableOutput = (!$this->jumpurl);

                        // Call hook for possible disabling of output:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['isOutputting'])) {
                        $_params = array('pObj' => &$this, 'enableOutput' => &$enableOutput);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['isOutputting'] as $_funcRef)  {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }

                return $enableOutput;
        }

        function processOutput()        {

                        // Set header for charset-encoding unless disabled
                if (!$this->config['config']['disableCharsetHeader'])   {
                        $headLine = 'Content-Type:text/html;charset='.trim($this->metaCharset);
                        header($headLine);
                }

                        // Set cache related headers to client (used to enable proxy / client caching!)
                if ($this->config['config']['sendCacheHeaders'])        {
                        $this->sendCacheHeaders();
                }

                        // Set headers, if any
                if ($this->config['config']['additionalHeaders'])       {
                        $headerArray = explode('|', $this->config['config']['additionalHeaders']);
                        while(list(,$headLine)=each($headerArray))      {
                                $headLine = trim($headLine);
                                header($headLine);
                        }
                }

                        // Send appropriate status code in case of temporary content
                if ($this->tempContent) {
                        $this->addTempContentHttpHeaders();
                }

                        // Make substitution of eg. username/uid in content only if cache-headers for client/proxy caching is NOT sent!
                if (!$this->isClientCachable)   {
                        $this->contentStrReplace();
                }

                                // Tidy up the code, if flag...
                if ($this->TYPO3_CONF_VARS['FE']['tidy_option'] == 'output')            {
                        $GLOBALS['TT']->push('Tidy, output','');
                                $this->content = $this->tidyHTML($this->content);
                        $GLOBALS['TT']->pull();
                }
                        // XHTML-clean the code, if flag set
                if ($this->doXHTML_cleaning() == 'output')              {
                        $GLOBALS['TT']->push('XHTML clean, output','');
                                $XHTML_clean = t3lib_div::makeInstance('t3lib_parsehtml');
                                $this->content = $XHTML_clean->XHTML_clean($this->content);
                        $GLOBALS['TT']->pull();
                }
                        // Fix local anchors in links, if flag set
                if ($this->doLocalAnchorFix() == 'output')              {
                        $GLOBALS['TT']->push('Local anchor fix, output','');
                                $this->prefixLocalAnchorsWithScript();
                        $GLOBALS['TT']->pull();
                }

                        // Hook for post-processing of page content before output:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['contentPostProc-output']))       {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['contentPostProc-output'] as $_funcRef)        {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }

                        // Send content-lenght header. Notice that all HTML content outside the length of the content-length header will be cut off! Therefore content of unknown length from included PHP-scripts and if admin users are logged in (admin panel might show...) we disable it!
                if ($this->config['config']['enableContentLengthHeader'] && !$this->isEXTincScript() && !$this->beUserLogin && !$this->doWorkspacePreview())    {
                        header('Content-Length: '.strlen($this->content));
                }
        }

        function sendCacheHeaders()     {

                        // Getting status whether we can send cache control headers for proxy caching:
                $doCache = $this->isStaticCacheble();

                        // This variable will be TRUE unless cache headers are configured to be sent ONLY if a branch does not allow logins and logins turns out to be allowed anyway...
                $loginsDeniedCfg = !$this->config['config']['sendCacheHeaders_onlyWhenLoginDeniedInBranch'] || !$this->loginAllowedInBranch;

                        // Finally, when backend users are logged in, do not send cache headers at all (Admin Panel might be displayed for instance).
                if ($doCache
                                && !$this->beUserLogin
                                && !$this->doWorkspacePreview()
                                && $loginsDeniedCfg)    {

                                // Build headers:
                        $headers = array(
                                'Last-Modified: '.gmdate('D, d M Y H:i:s T', $this->register['SYS_LASTCHANGED']),
                                'Expires: '.gmdate('D, d M Y H:i:s T', $this->cacheExpires),
                                'ETag: '.md5($this->content),
                                'Cache-Control: max-age='.($this->cacheExpires - $GLOBALS['EXEC_TIME']),                // no-cache
                                'Pragma: public',
                        );

                        $this->isClientCachable = TRUE;
                } else {
                                // Build headers:
                        $headers = array(
                                #'Last-Modified: '.gmdate('D, d M Y H:i:s T', $this->register['SYS_LASTCHANGED']),
                                #'ETag: '.md5($this->content),

                                #'Cache-Control: no-cache',
                                #'Pragma: no-cache',
                                'Cache-Control: private',               // Changed to this according to Ole Tange, FI.dk
                        );

                        $this->isClientCachable = FALSE;

                                // Now, if a backend user is logged in, tell him in the Admin Panel log what the caching status would have been:
                        if ($this->beUserLogin) {
                                if ($doCache)   {
                                        $GLOBALS['TT']->setTSlogMessage('Cache-headers with max-age "'.($this->cacheExpires - $GLOBALS['EXEC_TIME']).'" would have been sent');
                                } else {
                                        $reasonMsg = '';
                                        $reasonMsg.= !$this->no_cache ? '' : 'Caching disabled (no_cache). ';
                                        $reasonMsg.= !$this->isINTincScript() ? '' : '*_INT object(s) on page. ';
                                        $reasonMsg.= !$this->isEXTincScript() ? '' : '*_EXT object(s) on page. ';
                                        $reasonMsg.= !is_array($this->fe_user->user) ? '' : 'Frontend user logged in. ';
                                        $GLOBALS['TT']->setTSlogMessage('Cache-headers would disable proxy caching! Reason(s): "'.$reasonMsg.'"',1);
                                }
                        }
                }

                        // Send headers:
                foreach($headers as $hL)        {
                        header($hL);
                }
        }

        function isStaticCacheble()     {
                $doCache = !$this->no_cache
                                && !$this->isINTincScript()
                                && !$this->isEXTincScript()
                                && !$this->isUserOrGroupSet();
                return $doCache;
        }

        function contentStrReplace()    {
                        // Substitutes username mark with the username
                if ($this->fe_user->user['uid'])        {

                                // User name:
                        $token = trim($this->config['config']['USERNAME_substToken']);
                        $this->content = str_replace($token ? $token : '<!--###USERNAME###-->',$this->fe_user->user['username'],$this->content);

                                // User uid (if configured):
                        $token = trim($this->config['config']['USERUID_substToken']);
                        if ($token)     {
                                $this->content = str_replace($token, $this->fe_user->user['uid'], $this->content);
                        }
                }
                        // Substitutes get_URL_ID in case of GET-fallback
                if ($this->getMethodUrlIdToken) {
                        $this->content = str_replace($this->getMethodUrlIdToken, $this->fe_user->get_URL_ID, $this->content);
                }
        }

        function isEXTincScript()       {
                return is_array($this->config['EXTincScript']);
        }

        function storeSessionData()     {
                $this->fe_user->storeSessionData();
        }

        function setParseTime() {
                        // Compensates for the time consumed with Back end user initialization.
                $this->scriptParseTime = $GLOBALS['TT']->convertMicrotime($GLOBALS['TYPO3_MISC']['microtime_end'])
                                                                - $GLOBALS['TT']->convertMicrotime($GLOBALS['TYPO3_MISC']['microtime_start'])
                                                                - ($GLOBALS['TT']->convertMicrotime($GLOBALS['TYPO3_MISC']['microtime_BE_USER_end'])-$GLOBALS['TT']->convertMicrotime($GLOBALS['TYPO3_MISC']['microtime_BE_USER_start']));
        }

        function statistics()   {
                if ($this->config['config']['stat'] &&
                                (!strcmp('',$this->config['config']['stat_typeNumList']) || t3lib_div::inList(str_replace(' ','',$this->config['config']['stat_typeNumList']), $this->type)) &&
                                (!$this->config['config']['stat_excludeBEuserHits'] || !$this->beUserLogin) &&
                                (!$this->config['config']['stat_excludeIPList'] || !t3lib_div::cmpIP(t3lib_div::getIndpEnv('REMOTE_ADDR'),str_replace(' ','',$this->config['config']['stat_excludeIPList'])))) {

                        $GLOBALS['TT']->push('Stat');
                                if (t3lib_extMgm::isLoaded('sys_stat') && $this->config['config']['stat_mysql'])        {

                                                // Jumpurl:
                                        $sword = t3lib_div::_GP('sword');
                                        if ($sword)     {
                                                $jumpurl_msg = 'sword:'.$sword;
                                        } elseif ($this->jumpurl) {
                                                $jumpurl_msg = 'jumpurl:'.$this->jumpurl;
                                        } else {
                                                $jumpurl_msg = '';
                                        }

                                                // Flags: bits: 0 = BE_user, 1=Cached page?
                                        $flags=0;
                                        if ($this->beUserLogin) {$flags|=1;}
                                        if ($this->cacheContentFlag) {$flags|=2;}

                                                // Ref url:
                                        $refUrl = t3lib_div::getIndpEnv('HTTP_REFERER');
                                        $thisUrl = t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR');
                                        if (t3lib_div::isFirstPartOfStr($refUrl,$thisUrl))      {
                                                $refUrl='[LOCAL]';
                                        }

                                        $insertFields = array(
                                                'page_id' => intval($this->id),                                                 // id
                                                'page_type' => intval($this->type),                                             // type
                                                'jumpurl' => $jumpurl_msg,                                                              // jumpurl message
                                                'feuser_id' => $this->fe_user->user['uid'],                             // fe_user id, integer
                                                'cookie' => $this->fe_user->id,                                                 // cookie as set or retrieve. If people has cookies disabled this will vary all the time...
                                                'sureCookie' => hexdec(substr($this->fe_user->cookieId,0,8)),   // This is the cookie value IF the cookie WAS actually set. However the first hit where the cookie is set will thus NOT be logged here. So this lets you select for a session of at least two clicks...
                                                'rl0' => $this->config['rootLine'][0]['uid'],                   // RootLevel 0 uid
                                                'rl1' => $this->config['rootLine'][1]['uid'],                   // RootLevel 1 uid
                                                'client_browser' => $GLOBALS['CLIENT']['BROWSER'],              // Client browser (net, msie, opera)
                                                'client_version' => $GLOBALS['CLIENT']['VERSION'],              // Client version (double value)
                                                'client_os' => $GLOBALS['CLIENT']['SYSTEM'],                    // Client Operating system (win, mac, unix)
                                                'parsetime' => intval($this->scriptParseTime),                  // Parsetime for the page.
                                                'flags' => $flags,                                                                              // Flags: Is be user logged in? Is page cached?
                                                'IP' => t3lib_div::getIndpEnv('REMOTE_ADDR'),                   // Remote IP address
                                                'host' => t3lib_div::getIndpEnv('REMOTE_HOST'),                 // Remote Host Address
                                                'referer' => $refUrl,                                                                   // Referer URL
                                                'browser' => t3lib_div::getIndpEnv('HTTP_USER_AGENT'),  // User Agent Info.
                                                'tstamp' => $GLOBALS['EXEC_TIME']                                               // Time stamp
                                        );

                                                // Hook for preprocessing the list of fields to insert into sys_stat:
                                        if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['sys_stat-PreProcClass']))    {
                                                foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['sys_stat-PreProcClass'] as $_classRef)    {
                                                        $_procObj = &t3lib_div::getUserObj($_classRef);
                                                        $insertFields = $_procObj->sysstat_preProcessFields($insertFields,$this);
                                                }
                                        }


                                        $GLOBALS['TT']->push('Store SQL');
                                        $GLOBALS['TYPO3_DB']->exec_INSERTquery('sys_stat', $insertFields);
                                        $GLOBALS['TT']->pull();
                                }

                                        // Apache:
                                if ($this->config['config']['stat_apache'] && $this->config['stat_vars']['pageName'])   {
                                        if (@is_file($this->config['stat_vars']['logFile']))    {
                                                $LogLine = ((t3lib_div::getIndpEnv('REMOTE_HOST') && !$this->config['config']['stat_apache_noHost']) ? t3lib_div::getIndpEnv('REMOTE_HOST') : t3lib_div::getIndpEnv('REMOTE_ADDR')).' - - '.Date('[d/M/Y:H:i:s +0000]',$GLOBALS['EXEC_TIME']).' "GET '.$this->config['stat_vars']['pageName'].' HTTP/1.1" 200 '.strlen($this->content);
                                                if (!$this->config['config']['stat_apache_notExtended'])        {
                                                        $LogLine.= ' "'.t3lib_div::getIndpEnv('HTTP_REFERER').'" "'.t3lib_div::getIndpEnv('HTTP_USER_AGENT').'"';
                                                }

                                                $GLOBALS['TT']->push('Write to log file (fputs)');
                                                        $logfilehandle = fopen($this->config['stat_vars']['logFile'], 'a');
                                                        fputs($logfilehandle, $LogLine.chr(10));
                                                        @fclose($logfilehandle);
                                                $GLOBALS['TT']->pull();

                                                $GLOBALS['TT']->setTSlogMessage('Writing to logfile: OK',0);
                                        } else {
                                                $GLOBALS['TT']->setTSlogMessage('Writing to logfile: Error - logFile did not exist!',3);
                                        }
                                }
                        $GLOBALS['TT']->pull();
                }
        }

        function previewInfo()  {
                if ($this->fePreview)   {

                                if ($this->fePreview==2)        {
                                        $text = 'Preview of workspace "'.$this->whichWorkspace(TRUE).'" ('.$this->whichWorkspace().')';
                                } else {
                                        $text = 'PREVIEW!';
                                }

                                $stdMsg = '
                                <br />
                                <div align="center">
                                        <table border="3" bordercolor="black" cellpadding="2" bgcolor="red">
                                                <tr>
                                                        <td>&nbsp;&nbsp;<font face="Verdana" size="1"><b>'.htmlspecialchars($text).'</b></font>&nbsp;&nbsp;</td>
                                                </tr>
                                        </table>
                                </div>';

                                if ($this->fePreview==2)        {
                                        $temp_content = $this->config['config']['message_preview_workspace'] ?
                                                @sprintf($this->config['config']['message_preview_workspace'], $this->whichWorkspace(TRUE),$this->whichWorkspace()) :
                                                $stdMsg;
                                } else {
                                        $temp_content = $this->config['config']['message_preview'] ? $this->config['config']['message_preview'] : $stdMsg;
                                }
                                echo $temp_content;
                }
        }

        function hook_eofe()    {

                        // Call hook for end-of-frontend processing:
                if (is_array($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['hook_eofe']))    {
                        $_params = array('pObj' => &$this);
                        foreach($this->TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_fe.php']['hook_eofe'] as $_funcRef)     {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }
        }

        function beLoginLinkIPList()    {
                if ($this->config['config']['beLoginLinkIPList'])       {
                        if (t3lib_div::cmpIP(t3lib_div::getIndpEnv('REMOTE_ADDR'), $this->config['config']['beLoginLinkIPList']))       {
                                $label = !$this->beUserLogin ? $this->config['config']['beLoginLinkIPList_login'] : $this->config['config']['beLoginLinkIPList_logout'];
                                if ($label)     {
                                        if (!$this->beUserLogin)        {
                                                $link = '<a href="'.htmlspecialchars(TYPO3_mainDir.'index.php?redirect_url='.rawurlencode(t3lib_div::getIndpEnv('REQUEST_URI'))).'">'.$label.'</a>';
                                        } else {
                                                $link = '<a href="'.htmlspecialchars(TYPO3_mainDir.'index.php?L=OUT&redirect_url='.rawurlencode(t3lib_div::getIndpEnv('REQUEST_URI'))).'">'.$label.'</a>';
                                        }
                                        return $link;
                                }
                        }
                }
        }

        function addTempContentHttpHeaders() {
                header('HTTP/1.0 503 Service unavailable');
                header('Retry-after: 3600');
                header('Pragma: no-cache');
                header('Cache-control: no-cache');
                header('Expire: 0');
        }





















        /********************************************
         *
         * Various internal API functions
         *
         *******************************************/


        function makeSimulFileName($inTitle,$page,$type,$addParams='',$no_cache=false)  {
                $titleChars = intval($this->config['config']['simulateStaticDocuments_addTitle']);
                        // Default value is 30 but values > 1 will be override this
                if($titleChars==1)      { $titleChars = 30; }

                $out = '';
                if ($titleChars)        {
                        $out = $this->fileNameASCIIPrefix($inTitle, $titleChars);
                }
                $enc = '';

                if (strcmp($addParams,'') && !$no_cache)        {
                        switch ((string)$this->config['config']['simulateStaticDocuments_pEnc'])        {
                                case 'md5':
                                        $md5 = substr(md5($addParams),0,10);
                                        $enc = '+M5'.$md5;

                                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('md5hash', 'cache_md5params', 'md5hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($md5, 'cache_md5params'));
                                        if (!$GLOBALS['TYPO3_DB']->sql_num_rows($res))  {
                                                $insertFields = array(
                                                        'md5hash' => $md5,
                                                        'tstamp' => time(),
                                                        'type' => 1,
                                                        'params' => $addParams
                                                );

                                                $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_md5params', $insertFields);
                                        }
                                break;
                                case 'base64':
                                        $enc = '+B6'.str_replace('=','_',str_replace('/','-',base64_encode($addParams)));
                                break;
                        }
                }
                        // Setting page and type number:
                $url = $out.$page.$enc;
                $url.= ($type || $out || !$this->config['config']['simulateStaticDocuments_noTypeIfNoTitle']) ? '.'.$type : '';
                return $url;
        }

        function simulateStaticDocuments_pEnc_onlyP_proc($linkVars)     {
                $remainLinkVars = '';
                if (strcmp($linkVars,''))       {
                        $p = explode('&',$linkVars);
                        sort($p);       // This sorts the parameters - and may not be needed and further it will generate new MD5 hashes in many cases. Maybe not so smart. Hmm?
                        $rem = array();
                        foreach($p as $k => $v) {
                                if (strlen($v)) {
                                        list($pName) = explode('=',$v,2);
                                        $pName = rawurldecode($pName);
                                        if (!$this->pEncAllowedParamNames[$pName])      {
                                                unset($p[$k]);
                                                $rem[] = $v;
                                        }
                                } else unset($p[$k]);
                        }

                        $linkVars = count($p) ? '&'.implode('&',$p) : '';
                        $remainLinkVars = count($rem) ? '&'.implode('&',$rem) : '';
                }
                return array($linkVars, $remainLinkVars);
        }

        function getSimulFileName()     {
                $url = '';
                $url.= $this->makeSimulFileName($this->page['title'], $this->page['alias']?$this->page['alias']:$this->id, $this->type).'.html';
                return $url;
        }

        function setSimulReplacementChar() {
                $replacement = $defChar = t3lib_div::compat_version('4.0') ? '-' : '_';
                if (isset($this->config['config']['simulateStaticDocuments_replacementChar'])) {
                        $replacement = trim($this->config['config']['simulateStaticDocuments_replacementChar']);
                        if (urlencode($replacement) != $replacement) {
                                        // Invalid character
                                $replacement = $defChar;
                        }
                }
                $this->config['config']['simulateStaticDocuments_replacementChar'] = $replacement;
        }

        function fileNameASCIIPrefix($inTitle,$titleChars,$mergeChar='.')       {
                $out = $this->csConvObj->specCharsToASCII($this->renderCharset, $inTitle);
                        // Get replacement character
                $replacementChar = $this->config['config']['simulateStaticDocuments_replacementChar'];
                $replacementChars = '_\-' . ($replacementChar != '_' && $replacementChar != '-' ? $replacementChar : '');
                $out = preg_replace('/[^A-Za-z0-9_-]/', $replacementChar, trim(substr($out, 0, $titleChars)));
                $out = preg_replace('/([' . $replacementChars . ']){2,}/', '\1', $out);
                $out = preg_replace('/[' . $replacementChars . ']?$/', '', $out);
                $out = preg_replace('/^[' . $replacementChars . ']?/', '', $out);
                if (strlen($out)) {
                        $out.= $mergeChar;
                }

                return $out;
        }

        function encryptCharcode($n,$start,$end,$offset)        {
                $n = $n + $offset;
                if ($offset > 0 && $n > $end)   {
                        $n = $start + ($n - $end - 1);
                } else if ($offset < 0 && $n < $start)  {
                        $n = $end - ($start - $n - 1);
                }
                return chr($n);
        }

        function encryptEmail($string,$back=0)  {
                $out = '';

                if ($this->spamProtectEmailAddresses === 'ascii') {
                        for ($a=0; $a<strlen($string); $a++) {
                                $out .= '&#'.ord(substr($string, $a, 1)).';';
                        }
                } else  {
                                // like str_rot13() but with a variable offset and a wider character range
                        $len = strlen($string);
                        $offset = intval($this->spamProtectEmailAddresses)*($back?-1:1);
                        for ($i=0; $i<$len; $i++)       {
                                $charValue = ord($string{$i});
                                if ($charValue >= 0x2B && $charValue <= 0x3A)   {       // 0-9 . , - + / :
                                        $out .= $this->encryptCharcode($charValue,0x2B,0x3A,$offset);
                                } elseif ($charValue >= 0x40 && $charValue <= 0x5A)     {       // A-Z @
                                        $out .= $this->encryptCharcode($charValue,0x40,0x5A,$offset);
                                } else if ($charValue >= 0x61 && $charValue <= 0x7A)    {       // a-z
                                        $out .= $this->encryptCharcode($charValue,0x61,0x7A,$offset);
                                } else {
                                        $out .= $string{$i};
                                }
                        }
                }
                return $out;
        }

        function codeString($string, $decode=FALSE)     {

                if ($decode)    {
                        list($md5Hash, $str) = explode(':',$string,2);
                        $newHash = substr(md5($this->TYPO3_CONF_VARS['SYS']['encryptionKey'].':'.$str),0,10);
                        if (!strcmp($md5Hash, $newHash))        {
                                $str = base64_decode($str);
                                $str = $this->roundTripCryptString($str);
                                return $str;
                        } else return FALSE;    // Decoding check failed! Original string not produced by this server!
                } else {
                        $str = $string;
                        $str = $this->roundTripCryptString($str);
                        $str = base64_encode($str);
                        $newHash = substr(md5($this->TYPO3_CONF_VARS['SYS']['encryptionKey'].':'.$str),0,10);
                        return $newHash.':'.$str;
                }
        }

        function roundTripCryptString($string)  {
                $out = '';
                $strLen = strlen($string);
                $cryptLen = strlen($this->TYPO3_CONF_VARS['SYS']['encryptionKey']);

                for ($a=0; $a < $strLen; $a++)  {
                        $xorVal = $cryptLen>0 ? ord($this->TYPO3_CONF_VARS['SYS']['encryptionKey']{($a%$cryptLen)}) : 255;
                        $out.= chr(ord($string{$a}) ^ $xorVal);
                }

                return $out;
        }

        function checkFileInclude($incFile)     {
                return !$this->TYPO3_CONF_VARS['FE']['noPHPscriptInclude']
                        || substr($incFile,0,14)=='media/scripts/'
                        || substr($incFile,0,4+strlen(TYPO3_mainDir))==TYPO3_mainDir.'ext/'
                        || substr($incFile,0,7+strlen(TYPO3_mainDir))==TYPO3_mainDir.'sysext/'
                        || substr($incFile,0,14)=='typo3conf/ext/';
        }

        function newCObj()      {
                $this->cObj =t3lib_div::makeInstance('tslib_cObj');
                $this->cObj->start($this->page,'pages');
        }

        function setAbsRefPrefix()      {
                if ($this->absRefPrefix)        {
                        $this->content = str_replace('"media/', '"'.t3lib_extMgm::siteRelPath('cms').'tslib/media/', $this->content);
                        $this->content = str_replace('"fileadmin/', '"'.$this->absRefPrefix.'fileadmin/', $this->content);
                }
        }

        function baseUrlWrap($url)      {
                if ($this->baseUrl)     {
                        $urlParts = parse_url($url);
                        if (!strlen($urlParts['scheme']) && $url{0}!=='/')      {
                                $url = $this->baseUrl.$url;
                        }
                }
                return $url;
        }

        function printError($label,$header='Error!')    {
                t3lib_timeTrack::debug_typo3PrintError($header,$label,0,t3lib_div::getIndpEnv('TYPO3_SITE_URL'));
        }

        function updateMD5paramsRecord($hash)   {
                $GLOBALS['TYPO3_DB']->exec_UPDATEquery('cache_md5params', 'md5hash='.$GLOBALS['TYPO3_DB']->fullQuoteStr($hash, 'cache_md5params'), array('tstamp' => time()));
        }

        function tidyHTML($content)             {
                if ($this->TYPO3_CONF_VARS['FE']['tidy'] && $this->TYPO3_CONF_VARS['FE']['tidy_path'])  {
                        $oldContent = $content;
                        $fname = t3lib_div::tempnam('typo3_tidydoc_');          // Create temporary name
                        @unlink ($fname);       // Delete if exists, just to be safe.
                        $fp = fopen ($fname,'wb');      // Open for writing
                        fputs ($fp, $content);  // Put $content
                        @fclose ($fp);  // Close

                        exec ($this->TYPO3_CONF_VARS['FE']['tidy_path'].' '.$fname, $output);                   // run the $content through 'tidy', which formats the HTML to nice code.
                        @unlink ($fname);       // Delete the tempfile again
                        $content = implode(chr(10),$output);
                        if (!trim($content))    {
                                $content = $oldContent; // Restore old content due empty return value.
                                $GLOBALS['TT']->setTSlogMessage('"tidy" returned an empty value!',2);
                        }
                        $GLOBALS['TT']->setTSlogMessage('"tidy" content lenght: '.strlen($content),0);
                }
                return $content;
        }

        function prefixLocalAnchorsWithScript() {
                $scriptPath = substr(t3lib_div::getIndpEnv('TYPO3_REQUEST_URL'),strlen(t3lib_div::getIndpEnv('TYPO3_SITE_URL')));
                $this->content = preg_replace('/(<(a|area).*?href=")(#[^"]*")/i','$1' . htmlspecialchars($scriptPath) . '$3',$this->content);
        }

        function workspacePreviewInit() {
                $previewWS = t3lib_div::_GP('ADMCMD_previewWS');
                if ($this->beUserLogin && is_object($GLOBALS['BE_USER']) && t3lib_div::testInt($previewWS))     {
                        if ($previewWS>=-1 && ($previewWS==0 || $GLOBALS['BE_USER']->checkWorkspace($previewWS)))       {       // Check Access to workspace. Live (0) is OK to preview for all.
                                $this->workspacePreview = intval($previewWS);
                        } else {
                                $this->workspacePreview = -99;  // No preview, will default to "Live" at the moment
                        }
                }
        }

        function doWorkspacePreview()   {
                return (string)$this->workspacePreview!=='';
        }

        function whichWorkspace($returnTitle = FALSE)   {
                if ($this->doWorkspacePreview())        {
                        $ws = intval($this->workspacePreview);
                } elseif ($this->beUserLogin) {
                        $ws = $GLOBALS['BE_USER']->workspace;
                } else return FALSE;

                if ($returnTitle)       {
                        if ($ws===-1)   {
                                return 'Default Draft Workspace';
                        } else {
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('title', 'sys_workspace', 'uid='.intval($ws));
                                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                                        return $row['title'];
                                }
                        }
                } else {
                        return $ws;
                }
        }


























        /********************************************
         *
         * Various external API functions - for use in plugins etc.
         *
         *******************************************/


        function getStorageSiterootPids()       {
                $res=array();
                reset($this->rootLine);
                while(list(,$rC)=each($this->rootLine)) {
                        if (!$res['_STORAGE_PID'])      $res['_STORAGE_PID']=intval($rC['storage_pid']);
                        if (!$res['_SITEROOT']) $res['_SITEROOT']=$rC['is_siteroot']?intval($rC['uid']):0;
                }
                return $res;
        }

        function getPagesTSconfig()     {
                if (!is_array($this->pagesTSconfig))    {
                        reset($this->rootLine);
                        $TSdataArray = array();
                        $TSdataArray[] = $this->TYPO3_CONF_VARS['BE']['defaultPageTSconfig'];   // Setting default configuration:
                        while(list($k,$v)=each($this->rootLine))        {
                                $TSdataArray[]=$v['TSconfig'];
                        }
                                // Parsing the user TS (or getting from cache)
                        $TSdataArray = t3lib_TSparser::checkIncludeLines_array($TSdataArray);
                        $userTS = implode(chr(10).'[GLOBAL]'.chr(10),$TSdataArray);
                        $hash = md5('pageTS:'.$userTS);
                        $cachedContent = $this->sys_page->getHash($hash,0);
                        if (isset($cachedContent))      {
                                $this->pagesTSconfig = unserialize($cachedContent);
                        } else {
                                $parseObj = t3lib_div::makeInstance('t3lib_TSparser');
                                $parseObj->parse($userTS);
                                $this->pagesTSconfig = $parseObj->setup;
                                $this->sys_page->storeHash($hash,serialize($this->pagesTSconfig),'PAGES_TSconfig');
                        }
                }
                return $this->pagesTSconfig;
        }

        function setJS($key,$content='')        {
                if ($key)       {
                        switch($key)    {
                                case 'mouseOver':
                                        $this->additionalJavaScript[$key]=
'               // JS function for mouse-over
        function over(name,imgObj)      {       //
                if (version == "n3" && document[name]) {document[name].src = eval(name+"_h.src");}
                else if (typeof(document.getElementById)=="function" && document.getElementById(name)) {document.getElementById(name).src = eval(name+"_h.src");}
                else if (imgObj)        {imgObj.src = eval(name+"_h.src");}
        }
                // JS function for mouse-out
        function out(name,imgObj)       {       //
                if (version == "n3" && document[name]) {document[name].src = eval(name+"_n.src");}
                else if (typeof(document.getElementById)=="function" && document.getElementById(name)) {document.getElementById(name).src = eval(name+"_n.src");}
                else if (imgObj)        {imgObj.src = eval(name+"_n.src");}
        }';
                                break;
                                case 'openPic':
                                        $this->additionalJavaScript[$key]=
'       function openPic(url,winName,winParams) {       //
                var theWindow = window.open(url,winName,winParams);
                if (theWindow)  {theWindow.focus();}
        }';
                                break;
                                default:
                                        $this->additionalJavaScript[$key]=$content;
                                break;
                        }
                }
        }

        function setCSS($key,$content)  {
                if ($key)       {
                        switch($key)    {
                                default:
                                        $this->additionalCSS[$key]=$content;
                                break;
                        }
                }
        }

        function make_seed() {
                list($usec, $sec) = explode(' ', microtime());
                $seedV = (float)$sec + ((float)$usec * 100000);
                srand($seedV);
        }

        function uniqueHash($str='')    {
                return md5($this->uniqueString.'_'.$str.$this->uniqueCounter++);
        }

        function set_no_cache() {
                $this->no_cache = 1;
        }

        function set_cache_timeout_default($seconds)    {
                $this->cacheTimeOutDefault = intval($seconds);
        }

        function plainMailEncoded($email,$subject,$message,$headers='') {
                $urlmode = $this->config['config']['notification_email_urlmode'];       // '76', 'all', ''

                if ($urlmode)   {
                        $message = t3lib_div::substUrlsInPlainText($message,$urlmode);
                }

                $encoding = $this->config['config']['notification_email_encoding'] ? $this->config['config']['notification_email_encoding'] : '';
                $charset = $this->renderCharset;

                $convCharset = FALSE;   // do we need to convert mail data?
                if ($this->config['config']['notification_email_charset'])      {       // Respect config.notification_email_charset if it was set
                        $charset = $this->csConvObj->parse_charset($this->config['config']['notification_email_charset']);
                        if ($charset != $this->renderCharset)   {
                                $convCharset = TRUE;
                        }

                } elseif ($this->metaCharset != $this->renderCharset)   {       // Use metaCharset for mail if different from renderCharset
                        $charset = $this->metaCharset;
                        $convCharset = TRUE;
                }

                if ($convCharset)       {
                        $email = $this->csConvObj->conv($email,$this->renderCharset,$charset);
                        $subject = $this->csConvObj->conv($subject,$this->renderCharset,$charset);
                        $message = $this->csConvObj->conv($message,$this->renderCharset,$charset);
                        $headers = $this->csConvObj->conv($headers,$this->renderCharset,$charset);
                }

                t3lib_div::plainMailEncoded(
                        $email,
                        $subject,
                        $message,
                        $headers,
                        $encoding,
                        $charset
                );
        }













        /*********************************************
         *
         * Localization and character set conversion
         *
         *********************************************/

        function sL($input)     {
                if (strcmp(substr($input,0,4),'LLL:'))  {
                        $t = explode('|',$input);
                        return $t[$this->langSplitIndex] ? $t[$this->langSplitIndex] : $t[0];
                } else {
                        if (!isset($this->LL_labels_cache[$this->lang][$input])) {      // If cached label
                                $restStr = trim(substr($input,4));
                                $extPrfx='';
                                if (!strcmp(substr($restStr,0,4),'EXT:'))       {
                                        $restStr = trim(substr($restStr,4));
                                        $extPrfx='EXT:';
                                }
                                $parts = explode(':',$restStr);
                                $parts[0]=$extPrfx.$parts[0];
                                if (!isset($this->LL_files_cache[$parts[0]]))   {       // Getting data if not cached
                                        $this->LL_files_cache[$parts[0]] = $this->readLLfile($parts[0]);
                                }
                                $this->LL_labels_cache[$this->lang][$input] = $this->csConv($this->getLLL($parts[1],$this->LL_files_cache[$parts[0]]));
                        }
                        return $this->LL_labels_cache[$this->lang][$input];
                }
        }

        function readLLfile($fileRef)   {
                return t3lib_div::readLLfile($fileRef,$this->lang);
        }

        function getLLL($index,$LOCAL_LANG)     {
                if (strcmp($LOCAL_LANG[$this->lang][$index],''))        {
                        return $LOCAL_LANG[$this->lang][$index];
                } else {
                        return $LOCAL_LANG['default'][$index];
                }
        }

        function initLLvars()   {

                        // Setting language key and split index:
                $this->lang = $this->config['config']['language'] ? $this->config['config']['language'] : 'default';

                $ls = explode('|',TYPO3_languages);
                while(list($i,$v)=each($ls))    {
                        if ($v==$this->lang)    {$this->langSplitIndex=$i; break;}
                }

                        // Setting charsets:
                $this->renderCharset = $this->csConvObj->parse_charset($this->config['config']['renderCharset'] ? $this->config['config']['renderCharset'] : ($this->TYPO3_CONF_VARS['BE']['forceCharset'] ? $this->TYPO3_CONF_VARS['BE']['forceCharset'] : $this->defaultCharSet));    // Rendering charset of HTML page.
                $this->metaCharset = $this->csConvObj->parse_charset($this->config['config']['metaCharset'] ? $this->config['config']['metaCharset'] : $this->renderCharset);   // Output charset of HTML page.
                $this->labelsCharset = $this->csConvObj->parse_charset($this->csConvObj->charSetArray[$this->lang] ? $this->csConvObj->charSetArray[$this->lang] : 'iso-8859-1');
                if ($this->renderCharset != $this->labelsCharset)       {
                        $this->convCharsetToFrom = array(
                                'from' => $this->labelsCharset,
                                'to' => $this->renderCharset
                        );
                }
        }

        function csConv($str,$from='')  {
                if ($from)      {
                        $output = $this->csConvObj->conv($str,$this->csConvObj->parse_charset($from),$this->renderCharset,1);
                        return $output ? $output : $str;
                } elseif (is_array($this->convCharsetToFrom))   {
                        return $this->csConvObj->conv($str,$this->convCharsetToFrom['from'],$this->convCharsetToFrom['to'],1);
                } else {
                        return $str;
                }
        }

        function convOutputCharset($content,$label='')  {
                if ($this->renderCharset != $this->metaCharset) {
                        $content = $this->csConvObj->conv($content,$this->renderCharset,$this->metaCharset,TRUE);
                }

                return $content;
        }

        function convPOSTCharset()      {
                if ($this->renderCharset != $this->metaCharset && is_array($_POST) && count($_POST))    {
                        $this->csConvObj->convArray($_POST,$this->metaCharset,$this->renderCharset);
                        $GLOBALS['HTTP_POST_VARS'] = $_POST;
                }
        }
}


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

---