ExternalLinktype.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Linkvalidator\Linktype;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
use GuzzleHttp\Cookie\CookieJar;
use ‪TYPO3\CMS\Core\Http\RequestFactory;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\HttpUtility;
 
class ‪ExternalLinktype extends ‪AbstractLinktype
{
    protected ‪$urlReports = [];
 
    protected ‪$urlErrorParams = [];
 
    protected ‪$headers = [
        'User-Agent'      => 'TYPO3 linkvalidator',
        'Accept'          => '*/*',
        'Accept-Language' => '*',
        'Accept-Encoding' => '*',
    ];
 
    protected ‪$requestFactory;
 
    protected ‪$errorParams = [];
 
    public function ‪__construct(‪RequestFactory ‪$requestFactory = null)
    {
        $this->requestFactory = ‪$requestFactory ?: GeneralUtility::makeInstance(RequestFactory::class);
    }
 
    public function ‪checkLink($origUrl, $softRefEntry, $reference)
    {
        $isValidUrl = false;
        // use URL from cache, if available
        if (isset($this->urlReports[$origUrl])) {
            $this->‪setErrorParams($this->urlErrorParams[$origUrl]);
            return $this->urlReports[$origUrl];
        }
        $options = [
            'cookies' => GeneralUtility::makeInstance(CookieJar::class),
            'allow_redirects' => ['strict' => true],
            'headers'         => ‪$this->headers
        ];
        $url = $this->‪preprocessUrl($origUrl);
        if (!empty($url)) {
            $isValidUrl = $this->‪requestUrl($url, 'HEAD', $options);
            if (!$isValidUrl) {
                // HEAD was not allowed or threw an error, now trying GET
                $options['headers']['Range'] = 'bytes=0-4048';
                $isValidUrl = $this->‪requestUrl($url, 'GET', $options);
            }
        }
        $this->urlReports[$origUrl] = $isValidUrl;
        $this->urlErrorParams[$origUrl] = ‪$this->errorParams;
        return $isValidUrl;
    }
 
    protected function ‪requestUrl(string $url, string $method, array $options): bool
    {
        $this->errorParams = [];
        $isValidUrl = false;
        try {
            $response = $this->requestFactory->request($url, $method, $options);
            if ($response->getStatusCode() >= 300) {
                $this->errorParams['errorType'] = $response->getStatusCode();
                $this->errorParams['message'] = $this->‪getErrorMessage($this->errorParams);
            } else {
                $isValidUrl = true;
            }
        } catch (\GuzzleHttp\Exception\TooManyRedirectsException $e) {
            // redirect loop or too many redirects
            // todo: change errorType to 'redirect' (breaking change)
            $this->errorParams['errorType'] = 'loop';
            $this->errorParams['exception'] = $e->getMessage();
            $this->errorParams['message'] = $this->‪getErrorMessage($this->errorParams);
        } catch (\GuzzleHttp\Exception\ClientException $e) {
            if ($e->hasResponse()) {
                $this->errorParams['errorType'] = $e->getResponse()->getStatusCode();
            } else {
                $this->errorParams['errorType'] = 'unknown';
            }
            $this->errorParams['exception'] = $e->getMessage();
            $this->errorParams['message'] = $this->‪getErrorMessage($this->errorParams);
        } catch (\GuzzleHttp\Exception\RequestException $e) {
            $this->errorParams['errorType'] = 'network';
            $this->errorParams['exception'] = $e->getMessage();
            $this->errorParams['message'] = $this->‪getErrorMessage($this->errorParams);
        } catch (\Exception $e) {
            // Generic catch for anything else that may go wrong
            $this->errorParams['errorType'] = 'exception';
            $this->errorParams['exception'] = $e->getMessage();
            $this->errorParams['message'] = $this->‪getErrorMessage($this->errorParams);
        }
        return $isValidUrl;
    }
 
    public function ‪getErrorMessage(‪$errorParams)
    {
        $lang = $this->‪getLanguageService();
        $errorType = ‪$errorParams['errorType'];
        switch ($errorType) {
            case 300:
                $message = sprintf($lang->getLL('list.report.externalerror'), $errorType);
                break;
            case 403:
                $message = $lang->getLL('list.report.pageforbidden403');
                break;
            case 404:
                $message = $lang->getLL('list.report.pagenotfound404');
                break;
            case 500:
                $message = $lang->getLL('list.report.internalerror500');
                break;
            case 'loop':
                $message = sprintf(
                    $lang->getLL('list.report.redirectloop'),
                    ‪$errorParams['exception'],
                    ''
                );
                break;
            case 'exception':
                $message = sprintf($lang->getLL('list.report.httpexception'), ‪$errorParams['exception']);
                break;
            case 'network':
                $message = $lang->getLL('list.report.networkexception');
                if (‪$errorParams['exception']) {
                    $message .= ':' . ‪$errorParams['exception'];
                }
                break;
            default:
                $message = sprintf($lang->getLL('list.report.otherhttpcode'), $errorType, ‪$errorParams['exception']);
        }
 
        return $message;
    }
 
    public function ‪fetchType($value, $type, $key)
    {
        preg_match_all('/((?:http|https))(?::\\/\\/)(?:[^\\s<>]+)/i', $value['tokenValue'], $urls, PREG_PATTERN_ORDER);
        if (!empty($urls[0][0])) {
            $type = 'external';
        }
        return $type;
    }
 
    protected function ‪preprocessUrl(string $url): string
    {
        $url = html_entity_decode($url);
        $parts = parse_url($url);
        $host = (string)($parts['host'] ?? '');
        if ($host !== '') {
            try {
                $newDomain = (string)‪HttpUtility::idn_to_ascii($host);
                if (strcmp($host, $newDomain) !== 0) {
                    $parts['host'] = $newDomain;
                    $url = ‪HttpUtility::buildUrl($parts);
                }
            } catch (\Exception | \Throwable $e) {
                // ignore error and proceed with link checking
            }
        }
        return $url;
    }
}