Session cannot be started after headers have already been sent search►

66:         * @return mixed
67:         */
68:        public static function invokeSafe(string $function, array $args, callable $onError)
69:        {
70:            $prev = set_error_handler(function ($severity, $message, $file) use ($onError, &$prev, $function): ?bool {
71:                if ($file === __FILE__) {
72:                    $msg = ini_get('html_errors')
73:                        ? Html::htmlToText($message)
74:                        : $message;
75:                    $msg = preg_replace("#^$function\\(.*?\\): #", '', $msg);
76:                    if ($onError($msg, $severity) !== false) {
77:                        return null;
78:                    }
79:                }
80:    

'Session cannot be started after headers have already been sent'

2

75:                    $msg = preg_replace("#^$function\\(.*?\\): #", '', $msg);
76:                    if ($onError($msg, $severity) !== false) {
77:                        return null;
78:                    }
79:                }
80:    
81:                return $prev ? $prev(...func_get_args()) : false;
82:            });
83:    
84:            try {
85:                return $function(...$args);
86:            } finally {
87:                restore_error_handler();
88:            }
89:        }

110:                session_id($id); // causes resend of a cookie to make sure it has the right parameters
111:            }
112:    
113:            try {
114:                // session_start returns false on failure only sometimes (even in PHP >= 7.1)
115:                Nette\Utils\Callback::invokeSafe(
116:                    'session_start',
117:                    [['read_and_close' => $this->readAndClose]],
118:                    function (string $message) use (&$e): void {
119:                        $e = new Nette\InvalidStateException($message);
120:                    }
121:                );
122:            } catch (\Throwable $e) {
123:            }
124:    

'session_start'

78:            $this->options['cookie_secure'] = &$this->response->cookieSecure;
79:        }
80:    
81:    
82:        /**
83:         * Starts and initializes session data.
84:         * @throws Nette\InvalidStateException
85:         */
86:        public function start(): void
87:        {
88:            $this->doStart();
89:        }
90:    
91:    
92:        private function doStart($mustExists = false): void

31:        public function __construct($errorMessage)
32:        {
33:            parent::__construct();
34:            $this->setOmitted()
35:                ->setRequired()
36:                ->addRule(self::Protection, $errorMessage);
37:    
38:            $this->monitor(Presenter::class, function (Presenter $presenter): void {
39:                if (!$this->session) {
40:                    $this->session = $presenter->getSession();
41:                    $this->session->start();
42:                }
43:            });
44:    
45:            $this->monitor(Nette\Forms\Form::class, function (Nette\Forms\Form $form): void {

260:    
261:                        $this->monitors[$type][3] = $rec[3]; // mark as monitored
262:                    }
263:                }
264:            }
265:    
266:            if ($depth === 0) { // call listeners
267:                $prev = [];
268:                foreach ($listeners as $item) {
269:                    if ($item[0] && !in_array($item, $prev, true)) {
270:                        $item[0]($item[1]);
271:                        $prev[] = $item;
272:                    }
273:                }
274:            }

185:                $this->parent = null;
186:    
187:            } else { // add to parent
188:                $this->validateParent($parent);
189:                $this->parent = $parent;
190:                if ($name !== null) {
191:                    $this->name = $name;
192:                }
193:    
194:                $tmp = [];
195:                $this->refreshMonitors(0, $tmp);
196:            }
197:    
198:            return $this;
199:        }

0

75:    
76:                    $tmp[$k] = $v;
77:                }
78:    
79:                $this->components = $tmp;
80:            } else {
81:                $this->components[$name] = $component;
82:            }
83:    
84:            try {
85:                $component->setParent($this, $name);
86:            } catch (\Throwable $e) {
87:                unset($this->components[$name]); // undo
88:                throw $e;
89:            }

'forgotPasswordForm'

119:                if (!preg_match(self::NameRegexp, $name)) {
120:                    if ($throw) {
121:                        throw new Nette\InvalidArgumentException("Component name must be non-empty alphanumeric string, '$name' given.");
122:                    }
123:    
124:                    return null;
125:                }
126:    
127:                $component = $this->createComponent($name);
128:                if ($component && !isset($this->components[$name])) {
129:                    $this->addComponent($component, $name);
130:                }
131:            }
132:    
133:            $component = $this->components[$name] ?? null;

'forgotPasswordForm'

30:    
31:    
32:        /**
33:         * Returns component specified by name. Throws exception if component doesn't exist.
34:         * @param  string|int  $name
35:         * @throws Nette\InvalidArgumentException
36:         */
37:        public function offsetGet($name): IComponent
38:        {
39:            $name = is_int($name) ? (string) $name : $name;
40:            return $this->getComponent($name);
41:        }
42:    
43:    
44:        /**

'forgotPasswordForm'

299:    
300:            if (!$block) {
301:                $hint = ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
302:                    ? ", did you mean '$t'?"
303:                    : '.';
304:                $name = $layer ? "$layer $name" : $name;
305:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
306:            }
307:    
308:            $this->filter(
309:                function () use ($block, $params): void { reset($block->functions)($params); },
310:                $mod,
311:                $block->contentType,
312:                "block $name"
313:            );

null

354:            $block->functions = array_merge($block->functions, $functions);
355:        }
356:    
357:    
358:        /**
359:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
360:         */
361:        private function filter(callable $function, $mod, string $contentType, string $name): void
362:        {
363:            if ($mod === null || $mod === $contentType) {
364:                $function();
365:    
366:            } elseif ($mod instanceof \Closure) {
367:                echo $mod($this->capture($function), $contentType);
368:    

302:                    ? ", did you mean '$t'?"
303:                    : '.';
304:                $name = $layer ? "$layer $name" : $name;
305:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
306:            }
307:    
308:            $this->filter(
309:                function () use ($block, $params): void { reset($block->functions)($params); },
310:                $mod,
311:                $block->contentType,
312:                "block $name"
313:            );
314:        }
315:    
316:    

'html'

'html'

'block content'

161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {
175:                while (ob_get_level() > $level) {

193:    
194:            if ($this->referenceType === 'import') {
195:                if ($this->parentName) {
196:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
197:                }
198:    
199:            } elseif ($this->parentName) { // extends
200:                ob_start(function () {});
201:                $this->params = $this->main();
202:                ob_end_clean();
203:                $this->createTemplate($this->parentName, $this->params, 'extends')->render($block);
204:    
205:            } elseif ($block !== null) { // single block rendering
206:                $this->renderBlock($block, $this->params);
207:    

null

160:    
161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {

null

 92:    
 93:        /**
 94:         * Renders template to output.
 95:         * @param  object|mixed[]  $params
 96:         */
 97:        public function render(string $name, $params = [], ?string $block = null): void
 98:        {
 99:            $template = $this->createTemplate($name, $this->processParams($params));
100:            $template->global->coreCaptured = false;
101:            ($this->probe)($template);
102:            $template->render($block);
103:        }
104:    
105:    
106:        /**

null

36:            return $this->latte;
37:        }
38:    
39:    
40:        /**
41:         * Renders template to output.
42:         */
43:        public function render(?string $file = null, array $params = []): void
44:        {
45:            Nette\Utils\Arrays::toObject($params, $this);
46:            $this->latte->render($file ?: $this->file, $this);
47:        }
48:    
49:    
50:        /**

'/var/www/app/app/Modules/MultiAdmin/templates/User/forgotPassword.latte'

40:            return $this->source;
41:        }
42:    
43:    
44:        /**
45:         * Sends response to output.
46:         */
47:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
48:        {
49:            if ($this->source instanceof Nette\Application\UI\Template) {
50:                $this->source->render();
51:    
52:            } else {
53:                echo $this->source;
54:            }

161:    
162:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
163:            $response = $this->presenter->run(clone $request);
164:    
165:            if ($response instanceof Responses\ForwardResponse) {
166:                $request = $response->getRequest();
167:                goto process;
168:            }
169:    
170:            Arrays::invoke($this->onResponse, $this, $response);
171:            $response->send($this->httpRequest, $this->httpResponse);
172:        }
173:    
174:    
175:        public function processException(\Throwable $e): void

80:        }
81:    
82:    
83:        /**
84:         * Dispatch a HTTP request to a front controller.
85:         */
86:        public function run(): void
87:        {
88:            try {
89:                Arrays::invoke($this->onStartup, $this);
90:                $this->processRequest($this->createInitialRequest());
91:                Arrays::invoke($this->onShutdown, $this);
92:    
93:            } catch (\Throwable $e) {
94:                Arrays::invoke($this->onError, $this, $e);

14:        } elseif ($_SERVER['HTTP_X_FORWARDED_PROTO'] === 'http' && isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] == 80) { // http over proxy
15:            $_SERVER['HTTPS'] = 'Off';
16:            $_SERVER['SERVER_PORT'] = 80;
17:        }
18:    }
19:    
20:    require __DIR__ . '/../vendor/autoload.php';
21:    
22:    $container = App\Bootstrap::boot();
23:    $application = $container->getByType(Nette\Application\Application::class);
24:    $application->run();
25:    
26:    function dd($var, ?string $title = null, array $options = [])
27:    {
28:        Tracy\Debugger::barDump($var, $title, $options);