9.5/_external_linktype_8php_source.html

<?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;

    }

}