de/da7/HTTP_8php_source.html

 <?php
 namespace SimpleSAML\Utils;

 use SimpleSAML\Module;
 use SimpleSAML\Logger;

 class HTTP
 {

     private static function getSecurePOSTRedirectURL($destination, $data)
     {
         $session = \SimpleSAML_Session::getSessionFromRequest();
         $id = self::savePOSTData($session, $destination, $data);

         // get the session ID
         $session_id = $session->getSessionId();
         if (is_null($session_id)) {
             // this is a transient session, it is pointless to continue
             throw new \SimpleSAML_Error_Exception('Cannot save POST data to a transient session.');
         }

         // encrypt the session ID and the random ID
         $info = base64_encode(Crypto::aesEncrypt($session_id.':'.$id));

         $url = Module::getModuleURL('core/postredirect.php', array('RedirInfo' => $info));
         return preg_replace('#^https:#', 'http:', $url);
     }


     private static function getServerHost()
     {
         if (array_key_exists('HTTP_HOST', $_SERVER)) {
             $current = $_SERVER['HTTP_HOST'];
         } elseif (array_key_exists('SERVER_NAME', $_SERVER)) {
             $current = $_SERVER['SERVER_NAME'];
         } else {
             // almost certainly not what you want, but...
             $current = 'localhost';
         }

         if (strstr($current, ":")) {
             $decomposed = explode(":", $current);
             $port = array_pop($decomposed);
             if (!is_numeric($port)) {
                 array_push($decomposed, $port);
             }
             $current = implode(":", $decomposed);
         }
         return $current;
     }


     public static function getServerHTTPS()
     {
         if (!array_key_exists('HTTPS', $_SERVER)) {
             // not an https-request
             return false;
         }

         if ($_SERVER['HTTPS'] === 'off') {
             // IIS with HTTPS off
             return false;
         }

         // otherwise, HTTPS will be non-empty
         return !empty($_SERVER['HTTPS']);
     }


     public static function getServerPort()
     {
         $default_port = self::getServerHTTPS() ? '443' : '80';
         $port = isset($_SERVER['SERVER_PORT']) ? $_SERVER['SERVER_PORT'] : $default_port;

         // Take care of edge-case where SERVER_PORT is an integer
         $port = strval($port);

         if ($port !== $default_port) {
             return ':'.$port;
         }
         return '';
     }


     private static function redirect($url, $parameters = array())
     {
         if (!is_string($url) || empty($url) || !is_array($parameters)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }
         if (!empty($parameters)) {
             $url = self::addURLParameters($url, $parameters);
         }

         /* Set the HTTP result code. This is either 303 See Other or
          * 302 Found. HTTP 303 See Other is sent if the HTTP version
          * is HTTP/1.1 and the request type was a POST request.
          */
         if ($_SERVER['SERVER_PROTOCOL'] === 'HTTP/1.1' &&
             $_SERVER['REQUEST_METHOD'] === 'POST'
         ) {
             $code = 303;
         } else {
             $code = 302;
         }

         if (strlen($url) > 2048) {
             Logger::warning('Redirecting to a URL longer than 2048 bytes.');
         }

         if (!headers_sent()) {
             // set the location header
             header('Location: '.$url, true, $code);

             // disable caching of this response
             header('Pragma: no-cache');
             header('Cache-Control: no-cache, no-store, must-revalidate');
         }

         // show a minimal web page with a clickable link to the URL
         echo '<?xml version="1.0" encoding="UTF-8"?>'."\n";
         echo '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"';
         echo ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'."\n";
         echo '<html xmlns="http://www.w3.org/1999/xhtml">'."\n";
         echo "  <head>\n";
         echo '    <meta http-equiv="content-type" content="text/html; charset=utf-8">'."\n";
         echo '    <meta http-equiv="refresh" content="0;URL=\''.htmlspecialchars($url).'\'">'."\n";
         echo "    <title>Redirect</title>\n";
         echo "  </head>\n";
         echo "  <body>\n";
         echo "    <h1>Redirect</h1>\n";
         echo '      <p>You were redirected to: <a id="redirlink" href="'.htmlspecialchars($url).'">';
         echo htmlspecialchars($url)."</a>\n";
         echo '        <script type="text/javascript">document.getElementById("redirlink").focus();</script>'."\n";
         echo "      </p>\n";
         echo "  </body>\n";
         echo '</html>';

         // end script execution
         exit;
     }


     private static function savePOSTData(\SimpleSAML_Session $session, $destination, $data)
     {
         // generate a random ID to avoid replay attacks
         $id = Random::generateID();
         $postData = array(
             'post' => $data,
             'url'  => $destination,
         );

         // save the post data to the session, tied to the random ID
         $session->setData('core_postdatalink', $id, $postData);

         return $id;
     }


     public static function addURLParameters($url, $parameters)
     {
         if (!is_string($url) || !is_array($parameters)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $queryStart = strpos($url, '?');
         if ($queryStart === false) {
             $oldQuery = array();
             $url .= '?';
         } else {
             $oldQuery = substr($url, $queryStart + 1);
             if ($oldQuery === false) {
                 $oldQuery = array();
             } else {
                 $oldQuery = self::parseQueryString($oldQuery);
             }
             $url = substr($url, 0, $queryStart + 1);
         }

         $query = array_merge($oldQuery, $parameters);
         $url .= http_build_query($query, '', '&');

         return $url;
     }


     public static function checkSessionCookie($retryURL = null)
     {
         if (!is_null($retryURL) && !is_string($retryURL)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $session = \SimpleSAML_Session::getSessionFromRequest();
         if ($session->hasSessionCookie()) {
             return;
         }

         // we didn't have a session cookie. Redirect to the no-cookie page

         $url = Module::getModuleURL('core/no_cookie.php');
         if ($retryURL !== null) {
             $url = self::addURLParameters($url, array('retryURL' => $retryURL));
         }
         self::redirectTrustedURL($url);
     }


     public static function checkURLAllowed($url, array $trustedSites = null)
     {
         if (empty($url)) {
             return '';
         }
         $url = self::normalizeURL($url);

         if (filter_var($url, FILTER_VALIDATE_URL) === false) {
             throw new \SimpleSAML_Error_Exception('Invalid URL: '.$url);
         }

         // get the white list of domains
         if ($trustedSites === null) {
             $trustedSites = \SimpleSAML_Configuration::getInstance()->getValue('trusted.url.domains', array());
         }

         // validates the URL's host is among those allowed
         if (is_array($trustedSites)) {
             assert(is_array($trustedSites));
             $components = parse_url($url);
             $hostname = $components['host'];

             // check for userinfo
             if ((isset($components['user']) && strpos($components['user'], '\\') !== false) ||
                 (isset($components['pass']) && strpos($components['pass'], '\\') !== false)
             ) {
                 throw new \SimpleSAML_Error_Exception('Invalid URL: '.$url);
             }

             // allow URLs with standard ports specified (non-standard ports must then be allowed explicitly)
             if (isset($components['port']) &&
                 (($components['scheme'] === 'http' && $components['port'] !== 80) ||
                  ($components['scheme'] === 'https' && $components['port'] !== 443))
             ) {
                 $hostname = $hostname.':'.$components['port'];
             }

             $self_host = self::getSelfHostWithNonStandardPort();

             $trustedRegex = \SimpleSAML_Configuration::getInstance()->getValue('trusted.url.regex', false);

             $trusted = false;
             if ($trustedRegex) {
                 // add self host to the white list
                 $trustedSites[] = preg_quote($self_host);
                 foreach ($trustedSites as $regex) {
                     // Add start and end delimiters.
                     $regex = "@^{$regex}$@";
                     if (preg_match($regex, $hostname)) {
                         $trusted = true;
                         break;
                     }
                 }
             } else {
                 // add self host to the white list
                 $trustedSites[] = $self_host;
                 $trusted = in_array($hostname, $trustedSites, true);
             }

             // throw exception due to redirection to untrusted site
             if (!$trusted) {
                 throw new \SimpleSAML_Error_Exception('URL not allowed: '.$url);
             }
         }
         return $url;
     }


     public static function fetch($url, $context = array(), $getHeaders = false)
     {
         if (!is_string($url)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $config = \SimpleSAML_Configuration::getInstance();

         $proxy = $config->getString('proxy', null);
         if ($proxy !== null) {
             if (!isset($context['http']['proxy'])) {
                 $context['http']['proxy'] = $proxy;
             }
             $proxy_auth = $config->getString('proxy.auth', false);
             if ($proxy_auth !== false) {
                 $context['http']['header'] = "Proxy-Authorization: Basic ".base64_encode($proxy_auth);
             }
             if (!isset($context['http']['request_fulluri'])) {
                 $context['http']['request_fulluri'] = true;
             }
             /*
              * If the remote endpoint over HTTPS uses the SNI extension (Server Name Indication RFC 4366), the proxy
              * could introduce a mismatch between the names in the Host: HTTP header and the SNI_server_name in TLS
              * negotiation (thanks to Cristiano Valli @ GARR-IDEM to have pointed this problem).
              * See: https://bugs.php.net/bug.php?id=63519
              * These controls will force the same value for both fields.
              * Marco Ferrante (marco@csita.unige.it), Nov 2012
              */
             if (preg_match('#^https#i', $url)
                 && defined('OPENSSL_TLSEXT_SERVER_NAME')
                 && OPENSSL_TLSEXT_SERVER_NAME
             ) {
                 // extract the hostname
                 $hostname = parse_url($url, PHP_URL_HOST);
                 if (!empty($hostname)) {
                     $context['ssl'] = array(
                         'SNI_server_name' => $hostname,
                         'SNI_enabled'     => true,
                     );
                 } else {
                     Logger::warning('Invalid URL format or local URL used through a proxy');
                 }
             }
         }

         $context = stream_context_create($context);
         $data = @file_get_contents($url, false, $context);
         if ($data === false) {
             $error = error_get_last();
             throw new \SimpleSAML_Error_Exception('Error fetching '.var_export($url, true).':'.
                 (is_array($error) ? $error['message'] : 'no error available'));
         }

         // data and headers
         if ($getHeaders) {
             if (isset($http_response_header)) {
                 $headers = array();
                 foreach ($http_response_header as $h) {
                     if (preg_match('@^HTTP/1\.[01]\s+\d{3}\s+@', $h)) {
                         $headers = array(); // reset
                         $headers[0] = $h;
                         continue;
                     }
                     $bits = explode(':', $h, 2);
                     if (count($bits) === 2) {
                         $headers[strtolower($bits[0])] = trim($bits[1]);
                     }
                 }
             } else {
                 // no HTTP headers, probably a different protocol, e.g. file
                 $headers = null;
             }
             return array($data, $headers);
         }

         return $data;
     }


     public static function getAcceptLanguage()
     {
         if (!array_key_exists('HTTP_ACCEPT_LANGUAGE', $_SERVER)) {
             // no Accept-Language header, return an empty set
             return array();
         }

         $languages = explode(',', strtolower($_SERVER['HTTP_ACCEPT_LANGUAGE']));

         $ret = array();

         foreach ($languages as $l) {
             $opts = explode(';', $l);

             $l = trim(array_shift($opts)); // the language is the first element

             $q = 1.0;

             // iterate over all options, and check for the quality option
             foreach ($opts as $o) {
                 $o = explode('=', $o);
                 if (count($o) < 2) {
                     // skip option with no value
                     continue;
                 }

                 $name = trim($o[0]);
                 $value = trim($o[1]);

                 if ($name === 'q') {
                     $q = (float) $value;
                 }
             }

             // remove the old key to ensure that the element is added to the end
             unset($ret[$l]);

             // set the quality in the result
             $ret[$l] = $q;

             if (strpos($l, '-')) {
                 // the language includes a region part

                 // extract the language without the region
                 $l = explode('-', $l);
                 $l = $l[0];

                 // add this language to the result (unless it is defined already)
                 if (!array_key_exists($l, $ret)) {
                     $ret[$l] = $q;
                 }
             }
         }
         return $ret;
     }


     public static function guessBasePath()
     {
         if (!array_key_exists('REQUEST_URI', $_SERVER) || !array_key_exists('SCRIPT_FILENAME', $_SERVER)) {
             return '/';
         }
         // get the name of the current script
         $path = explode('/', $_SERVER['SCRIPT_FILENAME']);
         $script = array_pop($path);

         // get the portion of the URI up to the script, i.e.: /simplesaml/some/directory/script.php
         if (!preg_match('#^/(?:[^/]+/)*'.$script.'#', $_SERVER['REQUEST_URI'], $matches)) {
             return '/';
         }
         $uri_s = explode('/', $matches[0]);
         $file_s = explode('/', $_SERVER['SCRIPT_FILENAME']);

         // compare both arrays from the end, popping elements matching out of them
         while ($uri_s[count($uri_s) - 1] === $file_s[count($file_s) - 1]) {
             array_pop($uri_s);
             array_pop($file_s);
         }
         // we are now left with the minimum part of the URI that does not match anything in the file system, use it
         return join('/', $uri_s).'/';
     }


     public static function getBaseURL()
     {
         $globalConfig = \SimpleSAML_Configuration::getInstance();
         $baseURL = $globalConfig->getString('baseurlpath', 'simplesaml/');

         if (preg_match('#^https?://.*/?$#D', $baseURL, $matches)) {
             // full URL in baseurlpath, override local server values
             return rtrim($baseURL, '/').'/';
         } elseif ((preg_match('#^/?([^/]?.*/)$#D', $baseURL, $matches)) ||
             (preg_match('#^\*(.*)/$#D', $baseURL, $matches)) ||
             ($baseURL === '')
         ) {
             // get server values
             $protocol = 'http';
             $protocol .= (self::getServerHTTPS()) ? 's' : '';
             $protocol .= '://';

             $hostname = self::getServerHost();
             $port = self::getServerPort();
             $path = $globalConfig->getBasePath();

             return $protocol.$hostname.$port.$path;
         } else {
             /*
              * Invalid 'baseurlpath'. We cannot recover from this, so throw a critical exception and try to be graceful
              * with the configuration. Use a guessed base path instead of the one provided.
              */
             $c = $globalConfig->toArray();
             $c['baseurlpath'] = self::guessBasePath();
             throw new \SimpleSAML\Error\CriticalConfigurationError(
                 'Invalid value for \'baseurlpath\' in config.php. Valid format is in the form: '.
                 '[(http|https)://(hostname|fqdn)[:port]]/[path/to/simplesaml/]. It must end with a \'/\'.',
                 null,
                 $c
             );
         }
     }


     public static function getFirstPathElement($trailingslash = true)
     {
         if (preg_match('|^/(.*?)/|', $_SERVER['SCRIPT_NAME'], $matches)) {
             return ($trailingslash ? '/' : '').$matches[1];
         }
         return '';
     }


     public static function getPOSTRedirectURL($destination, $data)
     {
         if (!is_string($destination) || !is_array($data)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $config = \SimpleSAML_Configuration::getInstance();
         $allowed = $config->getBoolean('enable.http_post', false);

         if ($allowed && preg_match("#^http:#", $destination) && self::isHTTPS()) {
             // we need to post the data to HTTP
             $url = self::getSecurePOSTRedirectURL($destination, $data);
         } else { // post the data directly
             $session = \SimpleSAML_Session::getSessionFromRequest();
             $id = self::savePOSTData($session, $destination, $data);
             $url = Module::getModuleURL('core/postredirect.php', array('RedirId' => $id));
         }

         return $url;
     }


     public static function getSelfHost()
     {
         $decomposed = explode(':', self::getSelfHostWithNonStandardPort());
         return array_shift($decomposed);
     }

     public static function getSelfHostWithNonStandardPort()
     {
         $url = self::getBaseURL();

         $colon = strpos($url, '://');
         $start = $colon + 3;
         $length = strcspn($url, '/', $start);

         return substr($url, $start, $length);
     }

     public static function getSelfHostWithPath()
     {
         $baseurl = explode("/", self::getBaseURL());
         $elements = array_slice($baseurl, 3 - count($baseurl), count($baseurl) - 4);
         $path = implode("/", $elements);
         return self::getSelfHostWithNonStandardPort()."/".$path;
     }


     public static function getSelfURL()
     {
         $cfg = \SimpleSAML_Configuration::getInstance();
         $baseDir = $cfg->getBaseDir();
         $cur_path = realpath($_SERVER['SCRIPT_FILENAME']);
         // make sure we got a string from realpath()
         $cur_path = is_string($cur_path) ? $cur_path : '';
         // find the path to the current script relative to the www/ directory of SimpleSAMLphp
         $rel_path = str_replace($baseDir.'www'.DIRECTORY_SEPARATOR, '', $cur_path);
         // convert that relative path to an HTTP query
         $url_path = str_replace(DIRECTORY_SEPARATOR, '/', $rel_path);
         // find where the relative path starts in the current request URI
         $uri_pos = (!empty($url_path)) ? strpos($_SERVER['REQUEST_URI'], $url_path) : false;

         if ($cur_path == $rel_path || $uri_pos === false) {
             /*
              * We were accessed from an external script. This can happen in the following cases:
              *
              * - $_SERVER['SCRIPT_FILENAME'] points to a script that doesn't exist. E.g. functional testing. In this
              *   case, realpath() returns false and str_replace an empty string, so we compare them loosely.
              *
              * - The URI requested does not belong to a script in the www/ directory of SimpleSAMLphp. In that case,
              *   removing SimpleSAMLphp's base dir from the current path yields the same path, so $cur_path and
              *   $rel_path are equal.
              *
              * - The request URI does not match the current script. Even if the current script is located in the www/
              *   directory of SimpleSAMLphp, the URI does not contain its relative path, and $uri_pos is false.
              *
              * It doesn't matter which one of those cases we have. We just know we can't apply our base URL to the
              * current URI, so we need to build it back from the PHP environment, unless we have a base URL specified
              * for this case in the configuration. First, check if that's the case.
              */

             $appcfg = $cfg->getConfigItem('application', null);
             $appurl = ($appcfg instanceof \SimpleSAML_Configuration) ? $appcfg->getString('baseURL', '') : '';
             if (!empty($appurl)) {
                 $protocol = parse_url($appurl, PHP_URL_SCHEME);
                 $hostname = parse_url($appurl, PHP_URL_HOST);
                 $port = parse_url($appurl, PHP_URL_PORT);
                 $port = !empty($port) ? ':'.$port : '';
             } else { // no base URL specified for app, just use the current URL
                 $protocol = 'http';
                 $protocol .= (self::getServerHTTPS()) ? 's' : '';
                 $hostname = self::getServerHost();
                 $port = self::getServerPort();
             }
             return $protocol.'://'.$hostname.$port.$_SERVER['REQUEST_URI'];
         }

         return self::getBaseURL().$url_path.substr($_SERVER['REQUEST_URI'], $uri_pos + strlen($url_path));
     }


     public static function getSelfURLHost()
     {
         $url = self::getSelfURL();

         $colon = strpos($url, '://');
         $start = $colon + 3;
         $length = strcspn($url, '/', $start) + $start;
         return substr($url, 0, $length);
     }


     public static function getSelfURLNoQuery()
     {
         $url = self::getSelfURL();
         $pos = strpos($url, '?');
         if (!$pos) {
             return $url;
         }
         return substr($url, 0, $pos);
     }


     public static function isHTTPS()
     {
         return strpos(self::getSelfURL(), 'https://') === 0;
     }


     public static function normalizeURL($url)
     {
         if (!is_string($url)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $url = self::resolveURL($url, self::getSelfURL());

         // verify that the URL is to a http or https site
         if (!preg_match('@^https?://@i', $url)) {
             throw new \InvalidArgumentException('Invalid URL: '.$url);
         }

         return $url;
     }


     public static function parseQueryString($query_string)
     {
         if (!is_string($query_string)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $res = array();
         if (empty($query_string)) {
             return $res;
         }

         foreach (explode('&', $query_string) as $param) {
             $param = explode('=', $param);
             $name = urldecode($param[0]);
             if (count($param) === 1) {
                 $value = '';
             } else {
                 $value = urldecode($param[1]);
             }
             $res[$name] = $value;
         }
         return $res;
     }


     public static function redirectTrustedURL($url, $parameters = array())
     {
         if (!is_string($url) || !is_array($parameters)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $url = self::normalizeURL($url);
         self::redirect($url, $parameters);
     }


     public static function redirectUntrustedURL($url, $parameters = array())
     {
         if (!is_string($url) || !is_array($parameters)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $url = self::checkURLAllowed($url);
         self::redirect($url, $parameters);
     }


     public static function resolveURL($url, $base = null)
     {
         if ($base === null) {
             $base = self::getBaseURL();
         }

         if (!is_string($url) || !is_string($base)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         if (!preg_match('/^((((\w+:)\/\/[^\/]+)(\/[^?#]*))(?:\?[^#]*)?)(?:#.*)?/', $base, $baseParsed)) {
             throw new \InvalidArgumentException('Unable to parse base url: '.$base);
         }

         $baseDir = dirname($baseParsed[5].'filename');
         $baseScheme = $baseParsed[4];
         $baseHost = $baseParsed[3];
         $basePath = $baseParsed[2];
         $baseQuery = $baseParsed[1];

         if (preg_match('$^\w+:$', $url)) {
             return $url;
         }

         if (substr($url, 0, 2) === '//') {
             return $baseScheme.$url;
         }

         if ($url[0] === '/') {
             return $baseHost.$url;
         }
         if ($url[0] === '?') {
             return $basePath.$url;
         }
         if ($url[0] === '#') {
             return $baseQuery.$url;
         }

         // we have a relative path. Remove query string/fragment and save it as $tail
         $queryPos = strpos($url, '?');
         $fragmentPos = strpos($url, '#');
         if ($queryPos !== false || $fragmentPos !== false) {
             if ($queryPos === false) {
                 $tailPos = $fragmentPos;
             } elseif ($fragmentPos === false) {
                 $tailPos = $queryPos;
             } elseif ($queryPos < $fragmentPos) {
                 $tailPos = $queryPos;
             } else {
                 $tailPos = $fragmentPos;
             }

             $tail = substr($url, $tailPos);
             $dir = substr($url, 0, $tailPos);
         } else {
             $dir = $url;
             $tail = '';
         }

         $dir = System::resolvePath($dir, $baseDir);

         return $baseHost.$dir.$tail;
     }


     public static function setCookie($name, $value, $params = null, $throw = true)
     {
         if (!(is_string($name) && // $name must be a string
             (is_string($value) || is_null($value)) && // $value can be a string or null
             (is_array($params) || is_null($params)) && // $params can be an array or null
             is_bool($throw)) // $throw must be boolean
         ) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $default_params = array(
             'lifetime' => 0,
             'expire'   => null,
             'path'     => '/',
             'domain'   => null,
             'secure'   => false,
             'httponly' => true,
             'raw'      => false,
         );

         if ($params !== null) {
             $params = array_merge($default_params, $params);
         } else {
             $params = $default_params;
         }

         // Do not set secure cookie if not on HTTPS
         if ($params['secure'] && !self::isHTTPS()) {
             if ($throw) {
                 throw new \SimpleSAML\Error\CannotSetCookie(
                     'Setting secure cookie on plain HTTP is not allowed.',
                     \SimpleSAML\Error\CannotSetCookie::SECURE_COOKIE
                 );
             }
             Logger::warning('Error setting cookie: setting secure cookie on plain HTTP is not allowed.');
             return;
         }

         if ($value === null) {
             $expire = time() - 365 * 24 * 60 * 60;
         } elseif (isset($params['expire'])) {
             $expire = $params['expire'];
         } elseif ($params['lifetime'] === 0) {
             $expire = 0;
         } else {
             $expire = time() + $params['lifetime'];
         }

         if ($params['raw']) {
             $success = @setrawcookie(
                 $name,
                 $value,
                 $expire,
                 $params['path'],
                 $params['domain'],
                 $params['secure'],
                 $params['httponly']
             );
         } else {
             $success = @setcookie(
                 $name,
                 $value,
                 $expire,
                 $params['path'],
                 $params['domain'],
                 $params['secure'],
                 $params['httponly']
             );
         }

         if (!$success) {
             if ($throw) {
                 throw new \SimpleSAML\Error\CannotSetCookie(
                     'Headers already sent.',
                     \SimpleSAML\Error\CannotSetCookie::HEADERS_SENT
                 );
             }
             Logger::warning('Error setting cookie: headers already sent.');
         }
     }


     public static function submitPOSTData($destination, $data)
     {
         if (!is_string($destination) || !is_array($data)) {
             throw new \InvalidArgumentException('Invalid input parameters.');
         }

         $config = \SimpleSAML_Configuration::getInstance();
         $allowed = $config->getBoolean('enable.http_post', false);

         if ($allowed && preg_match("#^http:#", $destination) && self::isHTTPS()) {
             // we need to post the data to HTTP
             self::redirect(self::getSecurePOSTRedirectURL($destination, $data));
         }

         $p = new \SimpleSAML_XHTML_Template($config, 'post.php');
         $p->data['destination'] = $destination;
         $p->data['post'] = $data;
         $p->show();
         exit(0);
     }
 }
SimpleSAML\Utils\HTTP\redirect
static redirect($url, $parameters=array())
This function redirects the user to the specified address.
Definition: HTTP.php:147

SimpleSAML\Utils\HTTP\getServerHost
static getServerHost()
Retrieve Host value from $_SERVER environment variables.
Definition: HTTP.php:54

$_SERVER
if((!isset($_SERVER['DOCUMENT_ROOT'])) OR(empty($_SERVER['DOCUMENT_ROOT']))) $_SERVER['DOCUMENT_ROOT']
Definition: tcpdf_autoconfig.php:54

SimpleSAML\Module

SimpleSAML\Utils\HTTP\getServerHTTPS
static getServerHTTPS()
Retrieve HTTPS status from $_SERVER environment variables.
Definition: HTTP.php:84

Symfony\Polyfill\Mbstring
Definition: Mbstring.php:12

SimpleSAML\Utils\Crypto\aesEncrypt
static aesEncrypt($data)
Encrypt data using AES-256-CBC and the system-wide secret salt as key.
Definition: Crypto.php:146

$code
$code
Definition: example_050.php:99

$session
$session
Definition: proxy_ylocal.php:32

a

$destination
$destination
Definition: saml2-logout.php:50

$id
if(!array_key_exists('StateId', $_REQUEST)) $id
Definition: expirywarning.php:14

n
if(! $in) print Initializing normalization quick check tables n
Definition: UtfNormalGenerate.php:37

SimpleSAML\Utils
Definition: Arrays.php:2

SimpleSAML\Module\getModuleURL
static getModuleURL($resource, array $parameters=array())
Get absolute URL to a specified module resource.
Definition: Module.php:220

SimpleSAML\Logger
Definition: ErrorLogLoggingHandler.php:3

ILIAS\FileDelivery\http
static http()
Fetches the global http state from ILIAS.
Definition: HttpServiceAware.php:36

SimpleSAML\Logger\warning
static warning($string)
Definition: Logger.php:177

echo

SimpleSAML\Utils\HTTP\getServerPort
static getServerPort()
Retrieve the port number from $_SERVER environment variables.
Definition: HTTP.php:109

SimpleSAML\Utils\HTTP\getSecurePOSTRedirectURL
static getSecurePOSTRedirectURL($destination, $data)
Obtain a URL where we can redirect to securely post a form with the given data to a specific destinat...
Definition: HTTP.php:26

php

$url
$url
Definition: proxy_ylocal.php:28

$info
$info
Definition: index.php:5

$current
$current
Definition: frontpage_config.php:59

SimpleSAML_Session\getSessionFromRequest
static getSessionFromRequest()
Retrieves the current session.
Definition: Session.php:241

HTTP

$data
$data
Definition: bench.php:6