/web/pierke/flytobiggs.com/v3/lib/external/packages/twig/twig/src/Cache/FilesystemCache.php
$hash = hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $className);
return $this->directory.$hash[0].$hash[1].'/'.$hash.'.php';
}
public function load(string $key): void
{
if (is_file($key)) {
@include_once $key;
}
}
public function write(string $key, string $content): void
{
$dir = \dirname($key);
if (!is_dir($dir)) {
if (false === @mkdir($dir, 0777, true)) {
clearstatcache(true, $dir);
if (!is_dir($dir)) {
throw new \RuntimeException(\sprintf('Unable to create the cache directory (%s).', $dir));
}
}
} elseif (!is_writable($dir)) {
throw new \RuntimeException(\sprintf('Unable to write in the cache directory (%s).', $dir));
}
$tmpFile = tempnam($dir, basename($key));
if (false !== @file_put_contents($tmpFile, $content) && @rename($tmpFile, $key)) {
@chmod($key, 0666 & ~umask());
if (self::FORCE_BYTECODE_INVALIDATION == ($this->options & self::FORCE_BYTECODE_INVALIDATION)) {
// Compile cached file into bytecode cache
if (\function_exists('opcache_invalidate') && filter_var(\ini_get('opcache.enable'), \FILTER_VALIDATE_BOOLEAN)) {
@opcache_invalidate($key, true);
} elseif (\function_exists('apc_compile_file')) {
apc_compile_file($key);
}
}
return;
Arguments
"Unable to create the cache directory (/tigron/var/tmp/84)."
/web/pierke/flytobiggs.com/v3/lib/external/packages/twig/twig/src/Environment.php
if (null !== $index) {
$cls .= '___'.$index;
}
if (isset($this->loadedTemplates[$cls])) {
return $this->loadedTemplates[$cls];
}
if (!class_exists($cls, false)) {
$key = $this->cache->generateKey($name, $mainCls);
if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) {
$this->cache->load($key);
}
if (!class_exists($cls, false)) {
$source = $this->getLoader()->getSourceContext($name);
$content = $this->compileSource($source);
if (!isset($this->hotCache[$name])) {
$this->cache->write($key, $content);
$this->cache->load($key);
}
if (!class_exists($mainCls, false)) {
/* Last line of defense if either $this->bcWriteCacheFile was used,
* $this->cache is implemented as a no-op or we have a race condition
* where the cache was cleared between the above calls to write to and load from
* the cache.
*/
eval('?>'.$content);
}
if (!class_exists($cls, false)) {
throw new RuntimeError(\sprintf('Failed to load Twig template "%s", index "%s": cache might be corrupted.', $name, $index), -1, $source);
}
}
}
$this->extensionSet->initRuntime();
/web/pierke/flytobiggs.com/v3/lib/external/packages/twig/twig/src/Environment.php
* Loads a template.
*
* @param string|TemplateWrapper $name The template name
*
* @throws LoaderError When the template cannot be found
* @throws RuntimeError When a previously generated cache is corrupted
* @throws SyntaxError When an error occurred during compilation
*/
public function load($name): TemplateWrapper
{
if ($name instanceof TemplateWrapper) {
return $name;
}
if ($name instanceof Template) {
trigger_deprecation('twig/twig', '3.9', 'Passing a "%s" instance to "%s" is deprecated.', self::class, __METHOD__);
return $name;
}
return new TemplateWrapper($this, $this->loadTemplate($this->getTemplateClass($name), $name));
}
/**
* Loads a template internal representation.
*
* This method is for internal use only and should never be called
* directly.
*
* @param string $name The template name
* @param int|null $index The index if it is an embedded template
*
* @throws LoaderError When the template cannot be found
* @throws RuntimeError When a previously generated cache is corrupted
* @throws SyntaxError When an error occurred during compilation
*
* @internal
*/
public function loadTemplate(string $cls, string $name, ?int $index = null): Template
{
$mainCls = $cls;
/web/pierke/flytobiggs.com/v3/lib/external/packages/twig/twig/src/Environment.php
*/
public function getTemplateClass(string $name, ?int $index = null): string
{
$key = ($this->hotCache[$name] ?? $this->getLoader()->getCacheKey($name)).$this->optionsHash;
return '__TwigTemplate_'.hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $key).(null === $index ? '' : '___'.$index);
}
/**
* Renders a template.
*
* @param string|TemplateWrapper $name The template name
*
* @throws LoaderError When the template cannot be found
* @throws SyntaxError When an error occurred during compilation
* @throws RuntimeError When an error occurred during rendering
*/
public function render($name, array $context = []): string
{
return $this->load($name)->render($context);
}
/**
* Displays a template.
*
* @param string|TemplateWrapper $name The template name
*
* @throws LoaderError When the template cannot be found
* @throws SyntaxError When an error occurred during compilation
* @throws RuntimeError When an error occurred during rendering
*/
public function display($name, array $context = []): void
{
$this->load($name)->display($context);
}
/**
* Loads a template.
*
* @param string|TemplateWrapper $name The template name
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-template-twig/lib/Skeleton/Template/Twig/Twig.php
$environment = [
'post' => $_POST,
'get' => $_GET,
'cookie' => $_COOKIE,
'server' => $_SERVER,
];
$environment = array_merge($environment, $this->environment);
if ($this->i18n_available === true and $this->translation !== null) {
$environment['translation'] = $this->translation;
$environment['language'] = $this->translation->language;
}
if (isset($_SESSION)) {
$environment['session'] = $_SESSION;
}
$this->twig->setLoader($this->filesystem_loader);
$this->twig->addGlobal('env', $environment);
return $this->twig->render($template, $this->variables);
}
/**
* Validate
*
* @access public
* @param string $template
* @param string &$error
* @return bool
*/
public function validate($template, &$error): bool {
$chain_loader = new \Twig\Loader\ChainLoader([
new \Twig\Loader\FilesystemLoader()
]);
$environment = new \Twig\Environment($chain_loader, [
'cache' => false,
'debug' => false,
'autoescape' => 'html',
'auto_reload' => false,
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-template/lib/Skeleton/Template/Template.php
// Pass the environment variables to the template renderer
if (count($this->environment) > 0) {
foreach ($this->environment as $key => $value) {
$renderer->add_environment($key, $value);
}
}
// Pass the variables to the template renderer
foreach ($this->variables as $key => $value) {
$renderer->assign($key, $value);
}
// Set the translation object
if ($this->translation !== null) {
$renderer->set_translation($this->translation);
}
// Render
try {
return $renderer->render($template);
} catch (\Twig_Error_Loader $e) {
throw new Exception\Loader($e->getMessage());
} catch (\Twig\Error\LoaderError $e) {
throw new Exception\Loader($e->getMessage());
} catch (\SmartyException $e) {
if (strpos($e->getMessage(), 'Unable to load') === 0) {
throw new Exception\Loader($e->getMessage());
} else {
throw new Exception($e->getMessage());
}
}
}
/**
* Validate
*
* @access public
* @param string $template
*/
public function validate($template, &$error): bool {
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-application-web/lib/Skeleton/Application/Web/Template.php
/**
* Render a template
*
* @access public
* @return string $rendered_template
*/
public function render(string $template): string {
$csrf = Security\Csrf::get();
$this->add_environment('csrf_session_token_name', $csrf->get_session_token_name());
$this->add_environment('csrf_header_token_name', $csrf->get_header_token_name());
$this->add_environment('csrf_post_token_name', $csrf->get_post_token_name());
$this->add_environment('csrf_token', $csrf->get_session_token());
$replay = Security\Replay::get();
$this->add_environment('replay_session_tokens_name', $replay->get_session_tokens_name());
$this->add_environment('replay_header_token_name', $replay->get_header_token_name());
$this->add_environment('replay_post_token_name', $replay->get_post_token_name());
$output = $this->template->render($template);
$output = $csrf->inject($output);
$output = $replay->inject($output);
// Reverse rewrite the html
$application = \Skeleton\Core\Application::get();
if ($application->event_exists('rewrite', 'reverse')) {
$output = $application->call_event('rewrite', 'reverse', [$output]);
}
return $output;
}
/**
* Get function, returns Template object
*/
public static function get(): self {
if (self::$web_template === null) {
self::$web_template = new self();
}
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-application-web/lib/Skeleton/Application/Web/Template.php
*/
$this->template->add_template_path($path, $namespace, $prepend);
}
/**
* Add template directory
*
* @access public
*/
public function add_template_path(string $path, ?string $namespace = null, bool $prepend = false): void {
$this->template->add_template_path($path, $namespace, $prepend);
}
/**
* Display a template
*
* @access public
*/
public function display(string $template, bool $rewrite_html = true): void {
echo $this->render($template, $rewrite_html);
}
/**
* Render a template
*
* @access public
* @return string $rendered_template
*/
public function render(string $template): string {
$csrf = Security\Csrf::get();
$this->add_environment('csrf_session_token_name', $csrf->get_session_token_name());
$this->add_environment('csrf_header_token_name', $csrf->get_header_token_name());
$this->add_environment('csrf_post_token_name', $csrf->get_post_token_name());
$this->add_environment('csrf_token', $csrf->get_session_token());
$replay = Security\Replay::get();
$this->add_environment('replay_session_tokens_name', $replay->get_session_tokens_name());
$this->add_environment('replay_header_token_name', $replay->get_header_token_name());
$this->add_environment('replay_post_token_name', $replay->get_post_token_name());
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-application-web/lib/Skeleton/Application/Web/Module.php
// Find out which method to call, fall back to calling display()
if (
isset($_REQUEST['action']) === true
&& is_string($_REQUEST['action']) === true
&& method_exists($this, 'display_' . $_REQUEST['action']) === true
) {
if (class_exists('\Skeleton\Template\Template') === true) {
$template = \Skeleton\Application\Web\Template::Get();
$template->assign('action', $_REQUEST['action']);
}
call_user_func([$this, 'display_' . $_REQUEST['action']]);
} else {
$this->display();
}
// If the module has defined a template, render it
if ($this->template !== null && $this->template !== false) {
$template = \Skeleton\Application\Web\Template::Get();
$template->display($this->template);
}
}
/**
* Is login required?
*
* @access public
*/
public function is_login_required(): bool {
return $this->login_required;
}
/**
* Get the classname of the current module
*
* @access public
*/
public function get_name(): string {
$application = Application::get();
$module_namespace = $application->module_namespace;
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-application-web/lib/Skeleton/Application/Web/Module.php
$template->add_environment('sticky_session', $sticky->get_as_array());
}
// Call our magic secure() method before passing on the request
$allowed = true;
if (method_exists($this, 'secure') === true) {
$allowed = $this->secure();
}
// If the request is not allowed, make sure it gets handled properly
if ($allowed === false) {
$application->call_event('module', 'access_denied', [$this]);
} else {
// Call the bootstrap method if it exists
if (method_exists($this, 'bootstrap') === true) {
$this->bootstrap();
}
// Handle request
$this->handle_request();
}
// Call the teardown event if it exists
$application->call_event('module', 'teardown', [$this]);
}
/**
* get module_path
*
* @access public
* @return string $path
*/
public function get_module_path(): string {
$reflection = new \ReflectionClass($this);
$application = Application::Get();
$path = '/' . str_replace($application->module_path, '', $reflection->getFileName());
$path = strtolower($path);
return str_replace('.php', '', $path);
}
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-application-web/lib/Skeleton/Application/Web.php
/**
* Validate CSRF
*/
$csrf = \Skeleton\Application\Web\Security\Csrf::get();
if ($session_properties['resumed'] === true && !$csrf->validate()) {
$this->call_event('security', 'csrf_validate_failed');
}
/**
* Check for replays
*/
$replay = \Skeleton\Application\Web\Security\Replay::get();
if ($replay->check() === false) {
$this->call_event('security', 'replay_detected');
}
if ($module !== null) {
$this->call_event('module', 'bootstrap', [ $module ]);
$module->accept_request();
$this->call_event('module', 'teardown', [ $module ]);
}
}
/**
* Search module
*
* @access public
*/
public function route(string $request_uri): object {
/**
* Remove leading slash
*/
if ($request_uri[0] === '/') {
$request_uri = substr($request_uri, 1);
}
if (substr($request_uri, -1) === '/') {
$request_uri = substr($request_uri, 0, strlen($request_uri) - 1);
}
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-core/lib/Skeleton/Core/Application.php
*/
public function accept(): void {
/**
* If this application is launched while another application has been
* set, we need to take over the request_relative_uri
* This happens when whitin an application, another application is
* started.
*/
$application = self::get();
$this->request_relative_uri = $application->request_relative_uri;
$this->hostname = $application->hostname;
\Skeleton\Core\Application::set($this);
$continue = $this->call_event('application', 'bootstrap', []);
register_shutdown_function([$this, 'call_event'], 'application', 'teardown', []);
if ($continue) {
$this->run();
}
}
/**
* Run the application
*
* @access public
*/
abstract public function run(): void;
/**
* Load all events
*
* @access public
*/
public function load_event(string $requested_context): object {
if (isset($this->events[$requested_context])) {
return $this->events[$requested_context];
}
/web/pierke/flytobiggs.com/v3/lib/external/packages/tigron/skeleton-core/lib/Skeleton/Core/Http/Handler.php
} elseif (isset($_SERVER['SERVER_NAME'])) {
$hostname = $_SERVER['SERVER_NAME'];
} elseif (isset($_SERVER['SERVER_ADDR'])) {
$hostname = $_SERVER['SERVER_ADDR'];
} else {
throw new \Exception('Not a web request');
}
// Remove port number from host
$hostname = preg_replace('/:\d+$/', '', $hostname);
/**
* Define the application
*/
try {
$application = Application::detect($hostname, $request_uri);
} catch (\Skeleton\Core\Exception_Unknown_Application $e) {
Status::code_404('application');
}
$application->accept();
}
}
/web/pierke/flytobiggs.com/v3/webroot/handler.php
<?php
declare(strict_types=1);
ini_set('pcre.recursion_limit', 10000000);
ini_set('pcre.backtrack_limit', 10000000);
ini_set('pcre.jit', 0);
/**
* Handler file
*
* Calls the Handler class
*/
require_once '../lib/base/Bootstrap.php';
Bootstrap::boot();
\Skeleton\Core\Http\Handler::Run();