dc/d4d/Utilities_8php_source.html

 <?php


 class SimpleSAML_Utilities
 {

     public static $logMask = 0;


     public static function getSelfHost()
     {
         return \SimpleSAML\Utils\HTTP::getSelfHost();
     }


     public static function selfURLhost()
     {
         return \SimpleSAML\Utils\HTTP::getSelfURLHost();
     }


     public static function isHTTPS()
     {
         return \SimpleSAML\Utils\HTTP::isHTTPS();
     }


     public static function selfURLNoQuery()
     {
         return \SimpleSAML\Utils\HTTP::getSelfURLNoQuery();
     }


     public static function getSelfHostWithPath()
     {
         return \SimpleSAML\Utils\HTTP::getSelfHostWithPath();
     }


     public static function getFirstPathElement($trailingslash = true)
     {
         return \SimpleSAML\Utils\HTTP::getFirstPathElement($trailingslash);
     }


     public static function selfURL()
     {
         return \SimpleSAML\Utils\HTTP::getSelfURL();
     }


     public static function getBaseURL()
     {
         return \SimpleSAML\Utils\HTTP::getBaseURL();
     }


     public static function addURLparameter($url, $parameters)
     {
         return \SimpleSAML\Utils\HTTP::addURLParameters($url, $parameters);
     }


     public static function checkURLAllowed($url, array $trustedSites = null)
     {
         return \SimpleSAML\Utils\HTTP::checkURLAllowed($url, $trustedSites);
     }


     public static function parseStateID($stateId)
     {
         return SimpleSAML_Auth_State::parseStateID($stateId);
     }


     public static function checkDateConditions($start = null, $end = null)
     {
         $currentTime = time();

         if (!empty($start)) {
             $startTime = \SAML2\Utils::xsDateTimeToTimestamp($start);
             // Allow for a 10 minute difference in Time
             if (($startTime < 0) || (($startTime - 600) > $currentTime)) {
                 return false;
             }
         }
         if (!empty($end)) {
             $endTime = \SAML2\Utils::xsDateTimeToTimestamp($end);
             if (($endTime < 0) || ($endTime <= $currentTime)) {
                 return false;
             }
         }
         return true;
     }


     public static function generateID()
     {
         return SimpleSAML\Utils\Random::generateID();
     }


     public static function generateTimestamp($instant = null)
     {
         return SimpleSAML\Utils\Time::generateTimestamp($instant);
     }


     public static function parseDuration($duration, $timestamp = null)
     {
         return SimpleSAML\Utils\Time::parseDuration($duration, $timestamp);
     }


     public static function fatalError($trackId = 'na', $errorCode = null, Exception $e = null)
     {
         throw new SimpleSAML_Error_Error($errorCode, $e);
     }


     public static function ipCIDRcheck($cidr, $ip = null)
     {
         return SimpleSAML\Utils\Net::ipCIDRcheck($cidr, $ip);
     }


     private static function _doRedirect($url, $parameters = array())
     {
         assert(is_string($url));
         assert(!empty($url));
         assert(is_array($parameters));

         if (!empty($parameters)) {
             $url = self::addURLparameter($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) {
             SimpleSAML\Logger::warning('Redirecting to a URL longer than 2048 bytes.');
         }

         // Set the location header
         header('Location: '.$url, true, $code);

         // Disable caching of this response
         header('Pragma: no-cache');
         header('Cache-Control: no-cache, 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"'.
             ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'."\n";
         echo '<html xmlns="http://www.w3.org/1999/xhtml">';
         echo '<head>
                                         <meta http-equiv="content-type" content="text/html; charset=utf-8">
                                         <title>Redirect</title>
                                 </head>';
         echo '<body>';
         echo '<h1>Redirect</h1>';
         echo '<p>';
         echo 'You were redirected to: ';
         echo '<a id="redirlink" href="'.
             htmlspecialchars($url).'">'.htmlspecialchars($url).'</a>';
         echo '<script type="text/javascript">document.getElementById("redirlink").focus();</script>';
         echo '</p>';
         echo '</body>';
         echo '</html>';

         // End script execution
         exit;
     }


     public static function redirect($url, $parameters = array(), $allowed_redirect_hosts = null)
     {
         assert(is_string($url));
         assert(strlen($url) > 0);
         assert(is_array($parameters));

         if ($allowed_redirect_hosts !== null) {
             $url = self::checkURLAllowed($url, $allowed_redirect_hosts);
         } else {
             $url = self::normalizeURL($url);
         }
         self::_doRedirect($url, $parameters);
     }


     public static function redirectTrustedURL($url, $parameters = array())
     {
         \SimpleSAML\Utils\HTTP::redirectTrustedURL($url, $parameters);
     }


     public static function redirectUntrustedURL($url, $parameters = array())
     {
         \SimpleSAML\Utils\HTTP::redirectUntrustedURL($url, $parameters);
     }


     public static function transposeArray($in)
     {
         return SimpleSAML\Utils\Arrays::transpose($in);
     }


     public static function isDOMElementOfType(DOMNode $element, $name, $nsURI)
     {
         return SimpleSAML\Utils\XML::isDOMNodeOfType($element, $name, $nsURI);
     }


     public static function getDOMChildren(DOMElement $element, $localName, $namespaceURI)
     {
         return SimpleSAML\Utils\XML::getDOMChildren($element, $localName, $namespaceURI);
     }


     public static function getDOMText($element)
     {
         return SimpleSAML\Utils\XML::getDOMText($element);
     }


     public static function getAcceptLanguage()
     {
         return \SimpleSAML\Utils\HTTP::getAcceptLanguage();
     }


     public static function validateXML($xml, $schema)
     {
         $result = \SimpleSAML\Utils\XML::isValid($xml, $schema);
         return ($result === true) ? '' : $result;
     }


     public static function validateXMLDocument($message, $type)
     {
         \SimpleSAML\Utils\XML::checkSAMLMessage($message, $type);
     }


     public static function generateRandomBytes($length)
     {
         assert(is_int($length));

         return openssl_random_pseudo_bytes($length);
     }


     public static function stringToHex($bytes)
     {
         $ret = '';
         for ($i = 0; $i < strlen($bytes); $i++) {
             $ret .= sprintf('%02x', ord($bytes[$i]));
         }
         return $ret;
     }


     public static function resolvePath($path, $base = null)
     {
         return \SimpleSAML\Utils\System::resolvePath($path, $base);
     }


     public static function resolveURL($url, $base = null)
     {
         return \SimpleSAML\Utils\HTTP::resolveURL($url, $base);
     }


     public static function normalizeURL($url)
     {
         return \SimpleSAML\Utils\HTTP::normalizeURL($url);
     }


     public static function parseQueryString($query_string)
     {
         return \SimpleSAML\Utils\HTTP::parseQueryString($query_string);
     }


     public static function parseAttributes($attributes)
     {
         return SimpleSAML\Utils\Attributes::normalizeAttributesArray($attributes);
     }


     public static function getSecretSalt()
     {
         return SimpleSAML\Utils\Config::getSecretSalt();
     }


     public static function getLastError()
     {

         if (!function_exists('error_get_last')) {
             return '[Cannot get error message]';
         }

         $error = error_get_last();
         if ($error === null) {
             return '[No error message found]';
         }

         return $error['message'];
     }


     public static function resolveCert($path)
     {
         return \SimpleSAML\Utils\Config::getCertPath($path);
     }


     public static function loadPublicKey(SimpleSAML_Configuration $metadata, $required = false, $prefix = '')
     {
         return SimpleSAML\Utils\Crypto::loadPublicKey($metadata, $required, $prefix);
     }


     public static function loadPrivateKey(SimpleSAML_Configuration $metadata, $required = false, $prefix = '')
     {
         return SimpleSAML\Utils\Crypto::loadPrivateKey($metadata, $required, $prefix);
     }


     public static function formatDOMElement(DOMElement $root, $indentBase = '')
     {
         SimpleSAML\Utils\XML::formatDOMElement($root, $indentBase);
     }


     public static function formatXMLString($xml, $indentBase = '')
     {
         return SimpleSAML\Utils\XML::formatXMLString($xml, $indentBase);
     }


     public static function arrayize($data, $index = 0)
     {
         return SimpleSAML\Utils\Arrays::arrayize($data, $index);
     }


     public static function isAdmin()
     {
         return SimpleSAML\Utils\Auth::isAdmin();
     }


     public static function getAdminLoginURL($returnTo = null)
     {
         return SimpleSAML\Utils\Auth::getAdminLoginURL($returnTo);
     }


     public static function requireAdmin()
     {
         \SimpleSAML\Utils\Auth::requireAdmin();
     }


     public static function postRedirect($destination, $post)
     {
         \SimpleSAML\Utils\HTTP::submitPOSTData($destination, $post);
     }


     public static function createPostRedirectLink($destination, $post)
     {
         return \SimpleSAML\Utils\HTTP::getPOSTRedirectURL($destination, $post);
     }


     public static function createHttpPostRedirectLink($destination, $post)
     {
         assert(is_string($destination));
         assert(is_array($post));

         $postId = SimpleSAML\Utils\Random::generateID();
         $postData = array(
             'post' => $post,
             'url'  => $destination,
         );

         $session = SimpleSAML_Session::getSessionFromRequest();
         $session->setData('core_postdatalink', $postId, $postData);

         $redirInfo = base64_encode(SimpleSAML\Utils\Crypto::aesEncrypt($session->getSessionId().':'.$postId));

         $url = SimpleSAML\Module::getModuleURL('core/postredirect.php', array('RedirInfo' => $redirInfo));
         $url = preg_replace("#^https:#", "http:", $url);

         return $url;
     }


     public static function validateCA($certificate, $caFile)
     {
         \SimpleSAML\XML\Validator::validateCertificate($certificate, $caFile);
     }


     public static function initTimezone()
     {
         \SimpleSAML\Utils\Time::initTimezone();
     }


     public static function writeFile($filename, $data, $mode = 0600)
     {
         \SimpleSAML\Utils\System::writeFile($filename, $data, $mode);
     }


     public static function getTempDir()
     {
         return SimpleSAML\Utils\System::getTempDir();
     }


     public static function maskErrors($mask)
     {
         SimpleSAML\Logger::maskErrors($mask);
     }


     public static function popErrorMask()
     {
         SimpleSAML\Logger::popErrorMask();
     }


     public static function getDefaultEndpoint(array $endpoints, array $bindings = null)
     {
         return \SimpleSAML\Utils\Config\Metadata::getDefaultEndpoint($endpoints, $bindings);
     }


     public static function checkCookie($retryURL = null)
     {
         \SimpleSAML\Utils\HTTP::checkSessionCookie($retryURL);
     }


     public static function debugMessage($message, $type)
     {
         \SimpleSAML\Utils\XML::debugSAMLMessage($message, $type);
     }


     public static function fetch($path, $context = array(), $getHeaders = false)
     {
         return \SimpleSAML\Utils\HTTP::fetch($path, $context, $getHeaders);
     }


     public static function aesEncrypt($clear)
     {
         return SimpleSAML\Utils\Crypto::aesEncrypt($clear);
     }


     public static function aesDecrypt($encData)
     {
         return SimpleSAML\Utils\Crypto::aesDecrypt($encData);
     }


     public static function isWindowsOS()
     {
         return SimpleSAML\Utils\System::getOS() === SimpleSAML\Utils\System::WINDOWS;
     }


     public static function setCookie($name, $value, array $params = null, $throw = true)
     {
         \SimpleSAML\Utils\HTTP::setCookie($name, $value, $params, $throw);
     }
 }
SimpleSAML\Utils\Random\generateID
static generateID()
Generate a random identifier, ID_LENGTH bytes long.
Definition: Random.php:26

SimpleSAML_Utilities\debugMessage
static debugMessage($message, $type)
Definition: Utilities.php:658

SimpleSAML\Utils\System\writeFile
static writeFile($filename, $data, $mode=0600)
Atomically write a file.
Definition: System.php:183

SimpleSAML_Utilities\getDefaultEndpoint
static getDefaultEndpoint(array $endpoints, array $bindings=null)
Definition: Utilities.php:639

SimpleSAML_Utilities\resolveCert
static resolveCert($path)
Definition: Utilities.php:457

SimpleSAML\Utils\Attributes\normalizeAttributesArray
static normalizeAttributesArray($attributes)
Validate and normalize an array with attributes.
Definition: Attributes.php:79

SimpleSAML\Utils\Arrays\transpose
static transpose($array)
This function transposes a two-dimensional array, so that $a[&#39;k1&#39;][&#39;k2&#39;] becomes $a[&#39;k2&#39;][&#39;k1&#39;].
Definition: Arrays.php:39

$path
$path
Definition: aliased.php:25

$returnTo
if(!isset($_REQUEST['ReturnTo'])) $returnTo
Definition: authpage.php:16

SimpleSAML\Utils\Auth\requireAdmin
static requireAdmin()
Require admin access to the current page.
Definition: Auth.php:60

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

SimpleSAML\Logger\popErrorMask
static popErrorMask()
Pop an error mask.
Definition: Logger.php:322

$context
$context
Definition: webdav.php:25

SimpleSAML\Utils\Auth\isAdmin
static isAdmin()
Check whether the current user is admin.
Definition: Auth.php:42

SimpleSAML_Utilities\getAdminLoginURL
static getAdminLoginURL($returnTo=null)
Definition: Utilities.php:520

SimpleSAML_Utilities\getDOMText
static getDOMText($element)
Definition: Utilities.php:321

SimpleSAML_Utilities\parseAttributes
static parseAttributes($attributes)
Definition: Utilities.php:420

$result
$result
Definition: CleanUpTest.php:463

SimpleSAML_Utilities\formatDOMElement
static formatDOMElement(DOMElement $root, $indentBase='')
Definition: Utilities.php:484

SimpleSAML\Utils\Auth\getAdminLoginURL
static getAdminLoginURL($returnTo=null)
Retrieve a admin login URL.
Definition: Auth.php:22

SimpleSAML_Utilities\parseQueryString
static parseQueryString($query_string)
Definition: Utilities.php:410

SimpleSAML_Utilities\generateID
static generateID()
Definition: Utilities.php:150

$type
$type
Definition: proxy_ylocal.php:10

SimpleSAML_Utilities\resolveURL
static resolveURL($url, $base=null)
Definition: Utilities.php:392

SimpleSAML\Utils\Arrays\arrayize
static arrayize($data, $index=0)
Put a non-array variable into an array.
Definition: Arrays.php:24

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

SimpleSAML\Utils\System\getTempDir
static getTempDir()
This function retrieves the path to a directory where temporary files can be saved.
Definition: System.php:70

$code
$code
Definition: example_050.php:99

SimpleSAML\Utils\System\getOS
static getOS()
This function returns the Operating System we are running on.
Definition: System.php:29

SimpleSAML_Utilities\generateTimestamp
static generateTimestamp($instant=null)
Definition: Utilities.php:160

SimpleSAML_Utilities\redirectUntrustedURL
static redirectUntrustedURL($url, $parameters=array())
Definition: Utilities.php:284

SimpleSAML_Utilities\getLastError
static getLastError()
Definition: Utilities.php:438

$session
$session
Definition: proxy_ylocal.php:32

SimpleSAML_Utilities\parseDuration
static parseDuration($duration, $timestamp=null)
Definition: Utilities.php:169

SimpleSAML\Utils\XML\formatXMLString
static formatXMLString($xml, $indentBase='')
Format an XML string.
Definition: XML.php:246

$stateId
$stateId
Definition: saml2-acs.php:76

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

SimpleSAML\Utils\Crypto\aesDecrypt
static aesDecrypt($ciphertext)
Decrypt data using AES-256-CBC and the system-wide secret salt as key.
Definition: Crypto.php:81

SimpleSAML\Utils\XML\isDOMNodeOfType
static isDOMNodeOfType(\DOMNode $element, $name, $nsURI)
This function checks if the DOMElement has the correct localName and namespaceURI.
Definition: XML.php:357

SimpleSAML\Utils\XML\checkSAMLMessage
static checkSAMLMessage($message, $type)
This function performs some sanity checks on XML documents, and optionally validates them against the...
Definition: XML.php:35

SimpleSAML_Utilities\aesEncrypt
static aesEncrypt($clear)
Definition: Utilities.php:676

SimpleSAML_Utilities\normalizeURL
static normalizeURL($url)
Definition: Utilities.php:401

SimpleSAML\Utils\Config\getSecretSalt
static getSecretSalt()
Retrieve the secret salt.
Definition: Config.php:49

SimpleSAML_Utilities\selfURL
static selfURL()
Definition: Utilities.php:81

$retryURL
$retryURL
Definition: no_cookie.tpl.php:4

SimpleSAML_Utilities\popErrorMask
static popErrorMask()
Definition: Utilities.php:629

SimpleSAML\Utils\HTTP\redirectTrustedURL
static redirectTrustedURL($url, $parameters=array())
This function redirects to the specified URL without performing any security checks.
Definition: HTTP.php:959

$index
$index
Definition: metadata.php:60

SimpleSAML_Utilities\requireAdmin
static requireAdmin()
Definition: Utilities.php:529

SimpleSAML\Utils\Time\initTimezone
static initTimezone()
Initialize the timezone.
Definition: Time.php:51

$end
$end
Definition: bench_freebusygenerator.php:28

$metadata
$metadata['__DYNAMIC:1__']
Definition: adfs-idp-hosted.php:3

SimpleSAML_Utilities\getSelfHost
static getSelfHost()
Definition: Utilities.php:24

SimpleSAML_Utilities\getTempDir
static getTempDir()
Definition: Utilities.php:611

SimpleSAML\Utils\HTTP\redirectUntrustedURL
static redirectUntrustedURL($url, $parameters=array())
This function redirects to the specified URL after performing the appropriate security checks on it...
Definition: HTTP.php:991

SimpleSAML_Utilities\writeFile
static writeFile($filename, $data, $mode=0600)
Definition: Utilities.php:602

SimpleSAML_Utilities\getFirstPathElement
static getFirstPathElement($trailingslash=true)
Definition: Utilities.php:72

SimpleSAML\Utils\Time\generateTimestamp
static generateTimestamp($instant=null)
This function generates a timestamp on the form used by the SAML protocols.
Definition: Time.php:31

SimpleSAML_Utilities\formatXMLString
static formatXMLString($xml, $indentBase='')
Definition: Utilities.php:493

SimpleSAML_Utilities\loadPublicKey
static loadPublicKey(SimpleSAML_Configuration $metadata, $required=false, $prefix='')
Definition: Utilities.php:466

SimpleSAML_Utilities\checkDateConditions
static checkDateConditions($start=null, $end=null)
Definition: Utilities.php:126

$start
$start
Definition: bench.php:8

SimpleSAML_Utilities\getBaseURL
static getBaseURL()
Definition: Utilities.php:90

$bindings
$bindings
Definition: logout-iframe-post.php:52

$base
$base
Definition: index.php:4

SimpleSAML_Utilities\redirect
static redirect($url, $parameters=array(), $allowed_redirect_hosts=null)
Definition: Utilities.php:255

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

$certificate
if(@file_exists(dirname(__FILE__).'/lang/eng.php')) $certificate
Definition: example_052.php:77

SimpleSAML_Utilities\validateXMLDocument
static validateXMLDocument($message, $type)
Definition: Utilities.php:350

SimpleSAML\Utils\Crypto\loadPrivateKey
static loadPrivateKey(\SimpleSAML_Configuration $metadata, $required=false, $prefix='', $full_path=false)
Load a private key from metadata.
Definition: Crypto.php:195

SimpleSAML_Utilities\getAcceptLanguage
static getAcceptLanguage()
Definition: Utilities.php:331

SimpleSAML_Utilities\$logMask
static $logMask
Definition: Utilities.php:18

SimpleSAML\Utils\XML\debugSAMLMessage
static debugSAMLMessage($message, $type)
Helper function to log SAML messages that we send or receive.
Definition: XML.php:94

SimpleSAML_Utilities\createPostRedirectLink
static createPostRedirectLink($destination, $post)
Definition: Utilities.php:548

SimpleSAML
Attribute-related utility methods.

SimpleSAML_Utilities\validateCA
static validateCA($certificate, $caFile)
Definition: Utilities.php:584

DOMElement

$message
catch(Exception $e) $message
Definition: saml2-logout.php:34

SimpleSAML\Utils\Net\ipCIDRcheck
static ipCIDRcheck($cidr, $ip=null)
Check whether an IP address is part of a CIDR.
Definition: Net.php:26

$mask
$mask
Definition: example_042.php:90

SimpleSAML_Auth_State\parseStateID
static parseStateID($stateId)
Get the ID and (optionally) a URL embedded in a StateID, in the form &#39;id:url&#39;.
Definition: State.php:410

SimpleSAML\Utils\Time\parseDuration
static parseDuration($duration, $timestamp=null)
Interpret a ISO8601 duration value relative to a given timestamp.
Definition: Time.php:91

SimpleSAML\Utils\HTTP\setCookie
static setCookie($name, $value, $params=null, $throw=true)
Set a cookie.
Definition: HTTP.php:1104

SimpleSAML_Utilities\generateRandomBytes
static generateRandomBytes($length)
Definition: Utilities.php:359

SimpleSAML_Utilities\initTimezone
static initTimezone()
Definition: Utilities.php:593

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

getBaseURL
getBaseURL($t, $type='get', $key=null, $value=null)
Definition: showstats.php:145

SimpleSAML\XML\Validator\validateCertificate
static validateCertificate($certificate, $caFile)
Validate the certificate used to sign the XML against a CA file.
Definition: Validator.php:419

SimpleSAML_Utilities\getSecretSalt
static getSecretSalt()
Definition: Utilities.php:429

SimpleSAML_Utilities\selfURLhost
static selfURLhost()
Definition: Utilities.php:33

SimpleSAML_Configuration

PHPMailer\PHPMailer\$params
$params
Definition: get_oauth_token.php:84

SimpleSAML_Utilities\redirectTrustedURL
static redirectTrustedURL($url, $parameters=array())
Definition: Utilities.php:274

SimpleSAML_Utilities\checkCookie
static checkCookie($retryURL=null)
Definition: Utilities.php:649

$post
$post
Definition: post.php:34

SimpleSAML_Error_Error
Definition: Error.php:10

DOMNode

SimpleSAML\Utils\Crypto\loadPublicKey
static loadPublicKey(\SimpleSAML_Configuration $metadata, $required=false, $prefix='')
Get public key or certificate from metadata.
Definition: Crypto.php:265

SimpleSAML\Utils\System\WINDOWS
const WINDOWS
Definition: System.php:12

SimpleSAML_Utilities\aesDecrypt
static aesDecrypt($encData)
Definition: Utilities.php:685

SimpleSAML\Utils\HTTP\submitPOSTData
static submitPOSTData($destination, $data)
Submit a POST form to a specific destination.
Definition: HTTP.php:1202

SimpleSAML_Utilities\parseStateID
static parseStateID($stateId)
Definition: Utilities.php:117

$root
$root
Definition: sabredav.php:45

$attributes
if(array_key_exists('yes', $_REQUEST)) $attributes
Definition: getconsent.php:85

$postData
if($session===NULL) $postData
Definition: postredirect.php:34

$filename
$filename
Definition: buildRTE.php:89

SimpleSAML_Utilities\getDOMChildren
static getDOMChildren(DOMElement $element, $localName, $namespaceURI)
Definition: Utilities.php:312

SimpleSAML\Logger\maskErrors
static maskErrors($mask)
Disable error reporting for the given log levels.
Definition: Logger.php:304

SimpleSAML_Utilities\getSelfHostWithPath
static getSelfHostWithPath()
Definition: Utilities.php:62

$in
if(php_sapi_name() !='cli') $in
Definition: Utf8Test.php:37

echo

SimpleSAML_Utilities\isHTTPS
static isHTTPS()
Definition: Utilities.php:42

$timestamp
foreach($mandatory_scripts as $file) $timestamp
Definition: buildRTE.php:81

$errorCode
$errorCode
Definition: loginuserpass.php:41

exit
exit
Definition: backend.php:16

SimpleSAML_Utilities\setCookie
static setCookie($name, $value, array $params=null, $throw=true)
Definition: Utilities.php:703

SimpleSAML_Utilities\createHttpPostRedirectLink
static createHttpPostRedirectLink($destination, $post)
Definition: Utilities.php:558

SimpleSAML_Utilities\stringToHex
static stringToHex($bytes)
Definition: Utilities.php:370

SAML2\Utils\xsDateTimeToTimestamp
static xsDateTimeToTimestamp($time)
This function converts a SAML2 timestamp on the form yyyy-mm-ddThh:mm:ss(.s+)?Z to a UNIX timestamp...
Definition: Utils.php:721

SimpleSAML_Utilities\ipCIDRcheck
static ipCIDRcheck($cidr, $ip=null)
Definition: Utilities.php:187

SimpleSAML_Utilities\arrayize
static arrayize($data, $index=0)
Definition: Utilities.php:502

SimpleSAML_Utilities\isWindowsOS
static isWindowsOS()
Definition: Utilities.php:694

SimpleSAML_Utilities\fetch
static fetch($path, $context=array(), $getHeaders=false)
Definition: Utilities.php:667

SimpleSAML_Utilities\fatalError
static fatalError($trackId='na', $errorCode=null, Exception $e=null)
Definition: Utilities.php:178

$xml
$xml
Definition: fetch_windows_zones.php:11

$ret
$ret
Definition: parser.php:6

SimpleSAML_Utilities\transposeArray
static transposeArray($in)
Definition: Utilities.php:293

$i
$i
Definition: disco.tpl.php:19

$name
$name
Definition: client_example.php:35

SimpleSAML\Utils\HTTP\checkSessionCookie
static checkSessionCookie($retryURL=null)
Check for session cookie, and show missing-cookie page if it is missing.
Definition: HTTP.php:286

SimpleSAML_Utilities\_doRedirect
static _doRedirect($url, $parameters=array())
Definition: Utilities.php:193

php

$url
$url
Definition: proxy_ylocal.php:28

SimpleSAML_Utilities\isAdmin
static isAdmin()
Definition: Utilities.php:511

SimpleSAML_Utilities\loadPrivateKey
static loadPrivateKey(SimpleSAML_Configuration $metadata, $required=false, $prefix='')
Definition: Utilities.php:475

SimpleSAML_Utilities\selfURLNoQuery
static selfURLNoQuery()
Definition: Utilities.php:52

SimpleSAML_Utilities\maskErrors
static maskErrors($mask)
Definition: Utilities.php:620

SimpleSAML_Utilities\postRedirect
static postRedirect($destination, $post)
Definition: Utilities.php:538

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

SimpleSAML_Utilities\addURLparameter
static addURLparameter($url, $parameters)
Definition: Utilities.php:99

SimpleSAML_Utilities\isDOMElementOfType
static isDOMElementOfType(DOMNode $element, $name, $nsURI)
Definition: Utilities.php:303

SimpleSAML_Utilities\resolvePath
static resolvePath($path, $base=null)
Definition: Utilities.php:383

SimpleSAML_Utilities\validateXML
static validateXML($xml, $schema)
Definition: Utilities.php:340

$data
$data
Definition: bench.php:6

SimpleSAML_Utilities

Exception

SimpleSAML_Utilities\checkURLAllowed
static checkURLAllowed($url, array $trustedSites=null)
Definition: Utilities.php:108