*/
    protected function disconnectInternal()
    {
        if ($this->isConnected)
        {
            $this->isConnected = false;
            $this->resource->close();
        }
    }
 
    /*********************************************************
     * Query
     *********************************************************/
 
    /**
     * @inheritDoc
     */
    protected function queryInternal($sql, array $binds = null, Diag\SqlTrackerQuery $trackerQuery = null)
    {
        $this->connectInternal();
 
        $trackerQuery?->startQuery($sql, $binds);
 
        $result = $this->resource->query($sql);
 
        $trackerQuery?->finishQuery();
 
        $this->lastQueryResult = $result;
 
        if (!$result)
        {
            throw new SqlQueryException('Mysql query error', $this->getErrorMessage(), $sql);
        }
 
        return $result;
    }
 
    /**
     * @inheritDoc
     */

            $sql = $this->getSqlHelper()->getTopSql($sql, $limit, $offset);
        }
 
        $trackerQuery = null;
 
        if ($this->queryExecutingEnabled)
        {
            $connection = Main\Application::getInstance()->getConnectionPool()->getSlaveConnection($sql);
            if($connection === null)
            {
                $connection = $this;
            }
 
            if ($this->trackSql)
            {
                $trackerQuery = $this->sqlTracker->getNewTrackerQuery();
                $trackerQuery->setNode($connection->getNodeId());
            }
 
            $result = $connection->queryInternal($sql, $binds, $trackerQuery);
        }
        else
        {
            if ($this->disabledQueryExecutingDump === null)
            {
                $this->disabledQueryExecutingDump = array();
            }
 
            $this->disabledQueryExecutingDump[] = $sql;
            $result = true;
        }
 
        return $this->createResult($result, $trackerQuery);
    }
 
    /**
     * Executes a query, fetches a row and returns single field value
     * from the first column of the result.
     *
     * @param string $sql Sql text.

            throw new TransactionException('Nested rollbacks are unsupported.');
        }
    }
 
    /*********************************************************
     * Global named lock
     *********************************************************/
 
    /**
     * @inheritDoc
     */
    public function lock($name, $timeout = 0)
    {
        $timeout = (int)$timeout;
        $name = $this->getLockName($name);
 
        $pool = Application::getInstance()->getConnectionPool();
        $pool->useMasterOnly(true);
 
        $lock = $this->query("SELECT GET_LOCK('{$name}', {$timeout}) as L")->fetch();
 
        $pool->useMasterOnly(false);
 
        return ($lock["L"] == "1");
    }
 
    /**
     * @inheritDoc
     */
    public function unlock($name)
    {
        $name = $this->getLockName($name);
 
        $pool = Application::getInstance()->getConnectionPool();
        $pool->useMasterOnly(true);
 
        $lock = $this->query("SELECT RELEASE_LOCK('{$name}') as L")->fetch();
 
        $pool->useMasterOnly(false);
 

     * Locks specified session id
     *
     * @param string $id Session id.
     * @param int $timeout Lock timeout.
     * @return bool Returns true if lock occurred.
     */
    public static function lock($id, $timeout = 60)
    {
        $result = true;
 
        $pool = Application::getInstance()->getConnectionPool();
        $pool->useMasterOnly(true);
 
        $connection = static::getEntity()->getConnection();
        if (
            $connection instanceof MysqlCommonConnection
            || $connection instanceof PgsqlConnection
        )
        {
            $result = $connection->lock($id, (int)$timeout);
        }
        else
        {
            trigger_error(sprintf('SessionTable::lock not supported for connection of type "%s"', get_class($connection)), E_USER_WARNING);
        }
 
        $pool->useMasterOnly(false);
 
        return $result;
    }
 
    /**
     * Unlock specified session id
     *
     * @param string $id Session id.
     * @return bool Returns true if lock released.
     */
    public static function unlock($id)
    {
        $pool = Application::getInstance()->getConnectionPool();

        }
 
        return '';
    }
 
    public function processWrite($sessionId, $sessionData): bool
    {
        $this->processDestroy($sessionId);
        $result = UserSessionTable::add([
            'SESSION_ID' => $sessionId,
            'TIMESTAMP_X' => new \Bitrix\Main\Type\DateTime(),
            'SESSION_DATA' => base64_encode($sessionData),
        ]);
 
        return $result->isSuccess();
    }
 
    protected function lock($sessionId): bool
    {
        return UserSessionTable::lock($this->sessionId);
    }
 
    protected function unlock($sessionId): bool
    {
        return UserSessionTable::unlock($this->sessionId);
    }
 
    protected function processDestroy($sessionId): bool
    {
        return UserSessionTable::delete($sessionId)->isSuccess();
    }
 
    /**
     * @param int $maxLifeTime
     * @return int
     */
    public function gc($maxLifeTime): int
    {
        UserSessionTable::deleteOlderThan($maxLifeTime);
 

        {
            return '';
        }
 
        $this->sessionId = $sessionId;
        if ($this->prefetchId !== null)
        {
            $prefetchId = $this->prefetchId;
            $prefetchData = $this->prefetchData;
 
            $this->prefetchId = null;
            $this->prefetchData = null;
 
            if ($prefetchId === $this->sessionId)
            {
                return $prefetchData;
            }
        }
 
        if (!$this->readOnly && !$this->lock($this->sessionId))
        {
            $this->triggerLockFatalError();
        }
 
        return $this->processRead($sessionId);
    }
 
    abstract protected function processRead($sessionId): string;
 
    protected function triggerLockFatalError(string $additionalText = ''): void
    {
        $text = self::LOCK_ERROR_MESSAGE;
        if ($additionalText)
        {
            $text .= $additionalText;
        }
 
        $httpResponse = new HttpResponse();
        $httpResponse->setStatus('500 Internal Server Error');
        trigger_error($text, E_USER_ERROR);

 
        if ($this->isActive())
        {
            throw new \RuntimeException('Could not start session by PHP because session is active.');
        }
 
        if ($this->isHeadersSent($file, $line))
        {
            throw new \RuntimeException(
                "Could not start session because headers have already been sent. \"{$file}\":{$line}."
            );
        }
 
        $this->debug('Session tries to start at');
        $this->detectFirstUsage();
 
        try
        {
            $this->applySessionStartIniSettings($this->getSessionStartOptions());
            if (!session_start() && !$this->ignoringSessionStartErrors)
            {
                throw new \RuntimeException('Could not start session by PHP.');
            }
        }
        catch (\Error $error)
        {
            if ($this->shouldLogError($error))
            {
                $this->writeToLogError($error);
            }
 
            if (!$this->ignoringSessionStartErrors)
            {
                throw $error->getPrevious() ?: $error;
            }
        }
        $this->debug('Session started at');
 
        $this->sessionData = &$_SESSION;
        $this->started = true;

    }
 
    public function setId($id)
    {
        $this->session->setId($id);
    }
 
    public function getName(): string
    {
        return $this->session->getName();
    }
 
    public function setName($name)
    {
        $this->session->setName($name);
    }
 
    public function start(): bool
    {
        return $this->session->start();
    }
 
    public function regenerateId(): bool
    {
        return $this->session->regenerateId();
    }
 
    public function destroy()
    {
        $this->session->destroy();
    }
 
    public function save()
    {
        $this->session->save();
    }
 
    public function has($name)
    {
        return $this->session->has($name);

    header("X-DevSrv-CMS: Bitrix");
}
 
//agents
if (COption::GetOptionString("main", "check_agents", "Y") == "Y")
{
    $application->addBackgroundJob(["CAgent", "CheckAgents"], [], \Bitrix\Main\Application::JOB_PRIORITY_LOW);
}
 
//send email events
if (COption::GetOptionString("main", "check_events", "Y") !== "N")
{
    $application->addBackgroundJob(['\Bitrix\Main\Mail\EventManager', 'checkEvents'], [], \Bitrix\Main\Application::JOB_PRIORITY_LOW-1);
}
 
$healerOfEarlySessionStart = new HealerEarlySessionStart();
$healerOfEarlySessionStart->process($application->getKernelSession());
 
$kernelSession = $application->getKernelSession();
$kernelSession->start();
$application->getSessionLocalStorageManager()->setUniqueId($kernelSession->getId());
 
foreach (GetModuleEvents("main", "OnPageStart", true) as $arEvent)
{
    ExecuteModuleEventEx($arEvent);
}
 
//define global user object
$GLOBALS["USER"] = new CUser;
 
//session control from group policy
$arPolicy = $GLOBALS["USER"]->GetSecurityPolicy();
$currTime = time();
if (
    (
        //IP address changed
        $kernelSession['SESS_IP']
        && $arPolicy["SESSION_IP_MASK"] <> ''
        && (
            (ip2long($arPolicy["SESSION_IP_MASK"]) & ip2long($kernelSession['SESS_IP']))

<?php
 
if (!defined('START_EXEC_PROLOG_BEFORE_1'))
{
    define("START_EXEC_PROLOG_BEFORE_1", microtime(true));
}
 
$GLOBALS["BX_STATE"] = "PB";
if(isset($_REQUEST["BX_STATE"])) unset($_REQUEST["BX_STATE"]);
if(isset($_GET["BX_STATE"])) unset($_GET["BX_STATE"]);
if(isset($_POST["BX_STATE"])) unset($_POST["BX_STATE"]);
if(isset($_COOKIE["BX_STATE"])) unset($_COOKIE["BX_STATE"]);
if(isset($_FILES["BX_STATE"])) unset($_FILES["BX_STATE"]);
 
if(!isset($USER)) {global $USER;}
if(!isset($APPLICATION)) {global $APPLICATION;}
if(!isset($DB)) {global $DB;}
 
require_once(__DIR__."/../include.php");
 
CMain::PrologActions();
 
if (!defined('START_EXEC_PROLOG_BEFORE_2'))
{
    define("START_EXEC_PROLOG_BEFORE_2", microtime(true));
}
 

<?php
require_once(__DIR__ . "/../bx_root.php");
 
if (file_exists($_SERVER["DOCUMENT_ROOT"].BX_PERSONAL_ROOT."/html_pages/.enabled"))
{
    require_once(__DIR__ . "/../lib/composite/responder.php");
    Bitrix\Main\Composite\Responder::respond();
}
 
require_once(__DIR__ . "/prolog_before.php");
require($_SERVER["DOCUMENT_ROOT"].BX_ROOT."/modules/main/include/prolog_after.php");
 

<?require_once($_SERVER["DOCUMENT_ROOT"]."/bitrix/modules/main/include/prolog.php");?>

<?require($_SERVER["DOCUMENT_ROOT"]."/bitrix/header.php");
$APPLICATION->SetTitle("Каталог товаров сантехники Vannstudio.ru");
$APPLICATION->IncludeComponent(
    "bitrix:catalog", 
    "main", 
    array(
        "IBLOCK_TYPE" => "aspro_max_catalog",
        "IBLOCK_ID" => "2",
        "HIDE_NOT_AVAILABLE" => "N",
        "BASKET_URL" => "/basket/",
        "ACTION_VARIABLE" => "action",
        "PRODUCT_ID_VARIABLE" => "id",
        "SECTION_ID_VARIABLE" => "SECTION_ID",
        "PRODUCT_QUANTITY_VARIABLE" => "quantity",
        "PRODUCT_PROPS_VARIABLE" => "prop",
        "SEF_MODE" => "Y",
        "SEF_FOLDER" => "/catalog/",
        "AJAX_MODE" => "N",
        "AJAX_OPTION_JUMP" => "N",
        "AJAX_OPTION_STYLE" => "Y",
        "AJAX_OPTION_HISTORY" => "Y",
        "CACHE_TYPE" => "A",
        "CACHE_TIME" => "3600000",
        "CACHE_FILTER" => "Y",
        "CACHE_GROUPS" => "Y",
        "SET_TITLE" => "Y",
        "SET_STATUS_404" => "Y",
        "USE_ELEMENT_COUNTER" => "Y",
        "USE_FILTER" => "Y",
        "FILTER_NAME" => "MAX_SMART_FILTER",
        "FILTER_FIELD_CODE" => array(
            0 => "",
            1 => "",
        ),
        "FILTER_PROPERTY_CODE" => array(
            0 => "BRAND",
            1 => "IP_PROP955",
            2 => "attr_deliveryprice",
            3 => "attr_deliveryprice_tk",
            4 => "attr_model",

 
            if ((str_starts_with($urlTmp, "upload/") || (str_starts_with($urlTmp, "bitrix/") && !str_starts_with($urlTmp, "bitrix/services/") && !str_starts_with($urlTmp, "bitrix/groupdavphp"))))
                continue;
 
            $ext = strtolower(GetFileExtension($url));
            if ($ext != "php")
                continue;
 
            // D7 response is not available here
            if(stristr(php_sapi_name(), "cgi") !== false && (!defined("BX_HTTP_STATUS") || BX_HTTP_STATUS == false))
            {
                header("Status: 200 OK");
            }
            else
            {
                header($_SERVER["SERVER_PROTOCOL"]." 200 OK");
            }
 
            $_SERVER["REAL_FILE_PATH"] = $url;
            include_once($io->GetPhysicalName($_SERVER['DOCUMENT_ROOT'].$url));
            die();
        }
    }
}
 
//admin section 404
if(str_starts_with($requestUri, "/bitrix/admin/"))
{
    $_SERVER["REAL_FILE_PATH"] = "/bitrix/admin/404.php";
    include($_SERVER["DOCUMENT_ROOT"]."/bitrix/admin/404.php");
    die();
}
 
define("BX_CHECK_SHORT_URI", true);
 

<?
include_once($_SERVER['DOCUMENT_ROOT'].'/bitrix/modules/main/include/urlrewrite.php');
if(file_exists($_SERVER['DOCUMENT_ROOT'].'/404.php'))
    include_once($_SERVER['DOCUMENT_ROOT'].'/404.php');
?>