Poll the SSL for its checks.

@return void
18378
public function poll()
    {
        if (! count(config('eyewitness.application_domains'))) {
            $this->eye->logger()->debug('No application domain set for SSL monitor');
            return;
        }

        foreach (config('eyewitness.application_domains') as $domain) {
            if ($this->isValidDomain($domain)) {
                $this->startScan($domain);
            }
        }
    }
172476
public static function is_https()
    {
        if (!empty($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) !== 'off') {
            return TRUE;
        } elseif (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
            return TRUE;
        } elseif (!empty($_SERVER['HTTP_FRONT_END_HTTPS']) && strtolower($_SERVER['HTTP_FRONT_END_HTTPS']) !== 'off') {
            return TRUE;
        }
        return FALSE;
    }
732812
protected function _check() {
		$result = true;
		$this->out(__d('cake_installer', 'Checking PHP version'));
		$this->hr();
		$phpVesion = $this->InstallerCheck->checkPHPversion();
		if ($phpVesion !== null) {
			if ($phpVesion) {
				$state = '<success>' . __d('cake_installer', 'Ok') . '</success>';
			} else {
				$state = '<error>' . __d('cake_installer', 'Bad') . '</error>';
				$result = false;
			}
			$state = '[' . $state . ']';

			$message = ' * ' . __d('cake_installer', 'Current PHP version: %s', PHP_VERSION);
			$formattedMessage = $this->state->getState($message, $state, $this->maxWidth - 1);
		} else {
			$formattedMessage = __d('cake_installer', 'Ok');
		}
		$this->out($formattedMessage, 1);
		$this->hr();
		$this->nl(1);

		$this->out(__d('cake_installer', 'Checking PHP extensions'));
		$this->hr();
		$phpModules = $this->InstallerCheck->checkPhpExtensions();
		if ($phpModules !== null) {
			$result = true;
			$messages = [];
			$this->waiting->animateMessage();
			foreach ($phpModules as $moduleName => $moduleState) {
				switch ($moduleState) {
					case 2:
						$state = '<success>' . __d('cake_installer', 'Ok') . '</success>';
						break;
					case 1:
						$state = '<warning>' . __d('cake_installer', 'Ok') . '</warning>';
						break;
					default:
						$state = '<error>' . __d('cake_installer', 'Bad') . '</error>';
						$result = false;
				}
				$state = '[' . $state . ']';
				$message = ' * ' . __d('cake_installer', 'Checking module is loaded: \'%s\'', $moduleName);
				$messages[] = $this->state->getState($message, $state, $this->maxWidth - 1);
				$this->waiting->animateMessage();
			}
			$this->waiting->hideMessage();
		} else {
			$messages = __d('cake_installer', 'Ok');
		}
		$this->out($messages, 1);
		$this->hr();
		$this->nl(1);
		if ($result) {
			$this->out('<success>' . __d('cake_installer', 'Check completed successfully.') . '</success>');
		} else {
			$this->out('<error>' . __d('cake_installer', 'Check completed unsuccessfully.') . '</error>');
		}

		return $result;
	}
399068
public function isSecure()
    {
        $https = $this->server('HTTPS');
        return !empty($https) && 'off' !== strtolower($https) || (int)$this->server('SERVER_PORT') === 443 || $this->server('HTTP_X_FORWARDED_PROTO') === 'https';
    }
1082315
protected function initSSLContext()
    {
        if (!\EventUtil::sslRandPoll()) {
            Daemon::$process->log(get_class($this->pool) . ': EventUtil::sslRandPoll failed');
            return false;
        }
        $params = [
            \EventSslContext::OPT_VERIFY_PEER => $this->verifypeer,
            \EventSslContext::OPT_ALLOW_SELF_SIGNED => $this->allowselfsigned,
        ];
        if ($this->certfile !== null) {
            $params[\EventSslContext::OPT_LOCAL_CERT] = $this->certfile;
        }
        if ($this->pkfile !== null) {
            $params[\EventSslContext::OPT_LOCAL_PK] = $this->pkfile;
        }
        if ($this->passphrase !== null) {
            $params[\EventSslContext::OPT_PASSPHRASE] = $this->passphrase;
        }
        $hash = igbinary_serialize($params);
        if (!self::$contextCache) {
            self::$contextCache = new CappedStorageHits(self::$contextCacheSize);
        } elseif ($ctx = self::$contextCache->getValue($hash)) {
            return $ctx;
        }
        $ctx = new \EventSslContext(\EventSslContext::TLS_CLIENT_METHOD, $params);
        self::$contextCache->put($hash, $ctx);
        return $ctx;
    }
1140930
private function parseSSL()
    {
        if($this->request->getAttribute('isVerifyCA', false))
        {
            $this->settings['ssl_verify_peer'] = true;
            $caCert = $this->request->getAttribute('caCert');
            if(null !== $caCert)
            {
                $this->settings['ssl_cafile'] = $caCert;
            }
        }
        else
        {
            $this->settings['ssl_verify_peer'] = false;
        }
        $certPath = $this->request->getAttribute('certPath', '');
        if('' !== $certPath)
        {
            $this->settings['ssl_cert_file'] = $certPath;
        }
        $keyPath = $this->request->getAttribute('keyPath' , '');
        if('' !== $keyPath)
        {
            $this->settings['ssl_key_file'] = $keyPath;
        }
    }
327842
public function getIsSecureConnection()
    {
        $https = $this->getServerParam('HTTPS');
        if ($https !== null && (strcasecmp($https, 'on') === 0 || $https == 1)) {
            return true;
        }
        foreach ($this->secureProtocolHeaders as $header => $values) {
            if ($this->hasHeader($header)) {
                foreach ($values as $value) {
                    if (strcasecmp($this->getHeaderLine($header), $value) === 0) {
                        return true;
                    }
                }
            }
        }

        return false;
    }
939309
function supportsSSL()
    {
        $v = curl_version();
        if(is_array($v)) {
            return in_array('https', $v['protocols']);
        } elseif (is_string($v)) {
            return preg_match('/OpenSSL/i', $v);
        } else {
            return 0;
        }
    }
516673
public function verifyRoute(): void
    {
        $this->context->waitUntil($this->defaultTimeout, function () {
            return false !== strpos($this->context->getSession()->getCurrentUrl(), $this->route);
        });
    }
1282975
public function isSsl() : bool
	{
		$server = $this->server;
		$header = $this->header;
		if( isset( $header['https'] ) && ('1' == $header['https'] || 'on' == strtolower( $header['https'] )) ){
			return true;
		} elseif( isset( $server['request_scheme'] ) && 'https' == $server['request_scheme'] ){
			return true;
		} elseif( isset( $server['server_port'] ) && ('443' == $server['server_port']) ){
			return true;
		} elseif( isset( $server['http_x_forwarded_proto'] ) && 'https' == $server['http_x_forwarded_proto'] ){
			return true;
		}
		return false;
	}
1256868
public static function isPageSecure()
    {
        if (isset($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) === 'on') {

            //  Page is being served through HTTPS
            return true;

        } elseif (isset($_SERVER['SERVER_NAME']) && isset($_SERVER['REQUEST_URI']) && SECURE_BASE_URL != BASE_URL) {

            //  Not being served through HTTPS, but does the URL of the page begin
            //  with SECURE_BASE_URL (when BASE_URL is different)

            $sUrl = 'http://' . $_SERVER['SERVER_NAME'] . $_SERVER['REQUEST_URI'];
            return (bool) preg_match('#^' . SECURE_BASE_URL . '.*#', $sUrl);
        }

        //  Unknown, assume not
        return false;
    }
305720
public static function is_https($trust_proxy_headers = false)
    {
        // Check standard HTTPS header
        if (isset($_SERVER['HTTPS']) && !empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off') {
           return isset($_SERVER['HTTPS']) && !empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off';
        }

        // Check proxy headers if allowed
        return $trust_proxy_headers && isset($_SERVER['X-FORWARDED-PROTO']) && $_SERVER['X-FORWARDED-PROTO'] == 'https';

        // Default to not SSL
        return false;
    }
48475
public function poll()
    {
        try {
            foreach ($this->getMonitoredQueues() as $queue) {
                $this->storeTubeStats($queue);
                $this->deploySonar($queue);

                if (! $this->isQueueOnline($queue)) {
                    continue;
                }

                if (! $this->isWaitTimeOk($queue)) {
                    continue;
                }

                if (! $this->isPendingCountOk($queue)) {
                    continue;
                }

                if (! $this->isFailedCountOk($queue)) {
                    continue;
                }
            }
        } catch (Exception $e) {
            $this->eye->logger()->error('Error during queue poll process', $e);
        }
    }
980887
public function _isSsl() {
        $server = $_SERVER;
        if (isset($server['HTTPS']) && ('1' == $server['HTTPS'] || 'on' == strtolower($server['HTTPS']))) {
            return true;
        }
        elseif (isset($server['REQUEST_SCHEME']) && 'https' == $server['REQUEST_SCHEME']) {
            return true;
        }
        elseif (isset($server['SERVER_PORT']) && ('443' == $server['SERVER_PORT'])) {
            return true;
        }
        elseif (isset($server['HTTP_X_FORWARDED_PROTO']) && 'https' == $server['HTTP_X_FORWARDED_PROTO']) {
            return true;
        }
        return false;
    }
527173
public function check()
	{
		if($this->cipher === null)
			return false;
		if($this->compression === 0)
			return false;
		if($this->masterSeed === null)
			return false;
		if($this->transformSeed === null)
			return false;
		if($this->rounds === null)
			return false;
		if($this->encryptionIV === null)
			return false;
		if($this->startBytes === null)
			return false;
		if($this->headerHash === null)
			return false;
		if($this->randomStreamKey === null)
			return false;
		if($this->randomStream === 0)
			return false;
		return true;
	}
1347426
public function isSsl() {
        $server = $this->server();
        if (isset($server[ 'HTTPS' ]) && ('1' == $server[ 'HTTPS' ] || 'on' == strtolower($server[ 'HTTPS' ]))) {
            return true;
        } elseif (isset($server[ 'REQUEST_SCHEME' ]) && 'https' == $server[ 'REQUEST_SCHEME' ]) {
            return true;
        } elseif (isset($server[ 'SERVER_PORT' ]) && ('443' == $server[ 'SERVER_PORT' ])) {
            return true;
        } elseif (isset($server[ 'HTTP_X_FORWARDED_PROTO' ]) && 'https' == $server[ 'HTTP_X_FORWARDED_PROTO' ]) {
            return true;
        }
        return false;
    }
650949
protected function checkAndSetServerOptions()
    {

        // Specific query port defined
        if (array_key_exists(self::SERVER_OPTIONS_QUERY_PORT, $this->options)) {
            $this->port_query = (int)$this->options[self::SERVER_OPTIONS_QUERY_PORT];
        } else {
            // Do math based on the protocol class
            $this->port_query = $this->protocol->findQueryPort($this->port_client);
        }
    }