<h2>File Contents: /home/planet5/.trash/wordpress-seo-premium/src/initializers/redirect-handler.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/.trash/wordpress-seo-premium/src/initializers/redirect-handler.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

namespace Yoast\WP\SEO\Premium\Initializers;

use WP_Query;
use WPSEO_Premium_Redirect_Option;
use WPSEO_Redirect_Option;
use WPSEO_Redirect_Util;
use Yoast\WP\SEO\Conditionals\Front_End_Conditional;
use Yoast\WP\SEO\Initializers\Initializer_Interface;

/**
 * Class Redirect_Handler.
 */
class Redirect_Handler implements Initializer_Interface {

	/**
	 * Array where the redirects will stored.
	 *
	 * @var array
	 */
	protected $redirects;

	/**
	 * The matches parts of the URL in case of a matched regex redirect.
	 *
	 * @var array
	 */
	protected $url_matches = [];

	/**
	 * Is the current page being redirected.
	 *
	 * @var bool
	 */
	protected $is_redirected = false;

	/**
	 * The URL that is called at the moment.
	 *
	 * @var string
	 */
	private $request_url = &#039;&#039;;

	/**
	 * Sets the error template to include.
	 *
	 * @var string
	 */
	protected $template_file_path;

	/**
	 * Returns the conditionals based on which this loadable should be active.
	 *
	 * @return array The conditionals.
	 */
	public static function get_conditionals() {
		return [ Front_End_Conditional::class ];
	}

	/**
	 * Loads the redirect handler.
	 *
	 * @return void
	 */
	public function initialize() {
		// Only handle the redirect when the option for php redirects is enabled.
		if ( ! $this-&gt;load_php_redirects() ) {
			return;
		}

		if ( ! \function_exists( &#039;is_plugin_active_for_network&#039; ) ) {
			require_once \ABSPATH . &#039;wp-admin/includes/plugin.php&#039;;
		}
		// If the plugin is network activated, we wait for the plugins to be loaded before initializing.
		if ( \is_plugin_active_for_network( \WPSEO_PREMIUM_BASENAME ) ) {
			\add_action( &#039;plugins_loaded&#039;, [ $this, &#039;handle_redirects&#039; ], 16 );
		}
		else {
			$this-&gt;handle_redirects();
		}
	}

	/**
	 * Handles the 410 status code.
	 *
	 * @return void
	 */
	public function do_410() {
		$is_include_hook_set = $this-&gt;set_template_include_hook( &#039;410&#039; );

		if ( ! $is_include_hook_set ) {
			$this-&gt;set_404();
		}

		$this-&gt;status_header( 410 );
	}

	/**
	 * Handles the 451 status code.
	 *
	 * @return void
	 */
	public function do_451() {
		$is_include_hook_set = $this-&gt;set_template_include_hook( &#039;451&#039; );

		if ( ! $is_include_hook_set ) {
			$this-&gt;set_404();
		}

		$this-&gt;status_header( 451, &#039;Unavailable For Legal Reasons&#039; );
	}

	/**
	 * Returns the template that should be included.
	 *
	 * @param string $template The template that will included before executing hook.
	 *
	 * @return string Returns the template that should be included.
	 */
	public function set_template_include( $template ) {
		if ( ! empty( $this-&gt;template_file_path ) ) {
			return $this-&gt;template_file_path;
		}

		return $template;
	}

	/**
	 * Replaces the $regex vars with URL matches.
	 *
	 * @param string[] $matches Array with the matches from the matching redirect.
	 *
	 * @return string The replaced URL.
	 */
	public function format_regex_redirect_url( $matches ) {
		$arr_key = \substr( $matches[0], 1 );

		if ( isset( $this-&gt;url_matches[ $arr_key ] ) ) {
			return $this-&gt;url_matches[ $arr_key ];
		}

		return &#039;&#039;;
	}

	/**
	 * Sets the wp_query to 404 when this is an object.
	 *
	 * @return void
	 */
	public function set_404() {
		$wp_query         = $this-&gt;get_wp_query();
		$wp_query-&gt;is_404 = true;
	}

	/**
	 * Checks if the current URL matches a normal redirect.
	 *
	 * @param string $request_url The request url to look for.
	 *
	 * @return void
	 */
	protected function handle_normal_redirects( $request_url ) {
		// Setting the redirects.
		$redirects       = $this-&gt;get_redirects( WPSEO_Redirect_Option::OPTION_PLAIN );
		$this-&gt;redirects = $this-&gt;normalize_redirects( $redirects );

		$request_url = $this-&gt;normalize_url( $request_url );

		// Get the URL and doing the redirect.
		$redirect_url = $this-&gt;find_url( $request_url );

		if ( empty( $redirect_url ) ) {
			return;
		}

		if ( $this-&gt;normalize_url( $redirect_url[&#039;url&#039;] ) === $request_url ) {
			return;
		}

		$this-&gt;is_redirected = true;
		$this-&gt;do_redirect( $redirect_url[&#039;url&#039;], $redirect_url[&#039;type&#039;] );
	}

	/**
	 * Normalizes the url by trimming the slashes. If the given URL is a slash only,
	 * it will do nothing. By normalizing the URL there is a basis for matching multiple
	 * variants (Like: url, /url, /url/, url/).
	 *
	 * @param string $url The URL to normalize.
	 *
	 * @return string The modified url.
	 */
	protected function normalize_url( $url ) {
		if ( $url === &#039;/&#039; ) {
			return $url;
		}

		return \trim( $url, &#039;/&#039; );
	}

	/**
	 * Checks if the current URL matches a regex.
	 *
	 * @return void
	 */
	protected function handle_regex_redirects() {
		// Setting the redirects.
		$this-&gt;redirects = $this-&gt;get_redirects( WPSEO_Redirect_Option::OPTION_REGEX );

		foreach ( $this-&gt;redirects as $regex =&gt; $redirect ) {
			// Check if the URL matches the $regex.
			$this-&gt;match_regex_redirect( $regex, $redirect );
		}
	}

	/**
	 * Check if request URL matches one of the regex redirects.
	 *
	 * @param string $regex    The reqular expression to match.
	 * @param array  $redirect The URL that might be matched with the regex.
	 *
	 * @return void
	 */
	protected function match_regex_redirect( $regex, array $redirect ) {
		/*
		 * Escape the ` because we use ` to delimit the regex to prevent faulty redirects.
		 *
		 * Explicitly chosen not to use `preg_quote` because we need to be able to parse
		 * user provided regular expression syntax.
		 */
		$regex = \str_replace( &#039;`&#039;, &#039;\\`&#039;, $regex );

		// Suppress warning: a faulty redirect will give a warning and not an exception. So we can&#039;t catch it.
		// See issue: https://github.com/Yoast/wordpress-seo-premium/issues/662.
		// phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged
		if ( @\preg_match( &quot;`{$regex}`&quot;, $this-&gt;request_url, $this-&gt;url_matches ) === 1 ) {

			// Replace the $regex vars with URL matches.
			$redirect_url = \preg_replace_callback(
				&#039;/\$[0-9]+/&#039;,
				[ $this, &#039;format_regex_redirect_url&#039; ],
				$redirect[&#039;url&#039;]
			);

			$this-&gt;do_redirect( $redirect_url, $redirect[&#039;type&#039;] );
		}

		// Reset url_matches.
		$this-&gt;url_matches = [];
	}

	/**
	 * Gets the redirects from the options.
	 *
	 * @param string $option The option name that wil be fetched.
	 *
	 * @return array Returns the redirects for the given option.
	 */
	protected function get_redirects( $option ) {
		static $redirects;

		if ( ! isset( $redirects[ $option ] ) ) {
			$redirects[ $option ] = \get_option( $option, false );
		}

		if ( ! empty( $redirects[ $option ] ) ) {
			return $redirects[ $option ];
		}

		return [];
	}

	/**
	 * Performs the redirect.
	 *
	 * @param string $redirect_url  The target URL.
	 * @param string $redirect_type The type of the redirect.
	 *
	 * @return void
	 */
	protected function do_redirect( $redirect_url, $redirect_type ) {
		$redirect_url = $this-&gt;parse_target_url( $redirect_url );

		// Prevents redirecting to itself.
		if ( $this-&gt;home_url( $this-&gt;request_url ) === $redirect_url ) {
			return;
		}

		$redirect_types_without_target = [ 410, 451 ];
		if ( \in_array( $redirect_type, $redirect_types_without_target, true ) ) {
			$this-&gt;handle_redirect_without_target( $redirect_type );

			return;
		}

		$this-&gt;redirect( $redirect_url, $redirect_type );
	}

	/**
	 * Checks if a redirect has been executed.
	 *
	 * @return bool Whether a redirect has been executed.
	 */
	protected function is_redirected() {
		return $this-&gt;is_redirected === true;
	}

	/**
	 * Checks if we should load the PHP redirects.
	 *
	 * If Apache or NginX configuration is selected, don&#039;t load PHP redirects.
	 *
	 * @return bool True if PHP redirects should be loaded and used.
	 */
	protected function load_php_redirects() {

		if ( \defined( &#039;WPSEO_DISABLE_PHP_REDIRECTS&#039; ) &amp;&amp; \WPSEO_DISABLE_PHP_REDIRECTS === true ) {
			return false;
		}

		if ( \defined( &#039;WP_CLI&#039; ) &amp;&amp; \WP_CLI === true ) {
			return false;
		}

		$options = \get_option( &#039;wpseo_redirect&#039;, false );
		if ( $options === false ) {
			// If the option is not set, save it, to prevent a query for a non-existing option on every page load.
			\add_action( &#039;wp_head&#039;, [ $this, &#039;save_default_redirect_options&#039; ] );
			return false;
		}

		// If the PHP redirects are disabled intentionally, return false.
		if ( ! empty( $options[&#039;disable_php_redirect&#039;] ) &amp;&amp; $options[&#039;disable_php_redirect&#039;] === &#039;on&#039; ) {
			return false;
		}

		// PHP redirects are the enabled method of redirecting.
		return true;
	}

	/**
	 * Saves the default redirects options to the DB.
	 */
	public function save_default_redirect_options() {
		$redirect_option = WPSEO_Premium_Redirect_Option::get_instance();
		\update_option( &#039;wpseo_redirect&#039;, $redirect_option-&gt;get_defaults(), true );
	}

	/**
	 * Gets the request URI.
	 *
	 * @return string
	 */
	protected function get_request_uri() {
		$request_uri = &#039;&#039;;

		if ( isset( $_SERVER[&#039;REQUEST_URI&#039;] ) ) {
			// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- We sanitize after decoding.
			$request_uri = \sanitize_text_field( \rawurldecode( \wp_unslash( $_SERVER[&#039;REQUEST_URI&#039;] ) ) );
		}

		return $this-&gt;strip_subdirectory( $request_uri );
	}

	/**
	 * Normalizes the redirects by raw url decoding the origin.
	 *
	 * @param array $redirects The redirects to normalize.
	 *
	 * @return array The normalized redirects.
	 */
	protected function normalize_redirects( $redirects ) {
		$normalized_redirects = [];

		foreach ( $redirects as $origin =&gt; $redirect ) {
			$normalized_redirects[ \rawurldecode( $origin ) ] = $redirect;
		}

		return $normalized_redirects;
	}

	/**
	 * Sets the request URL and sanitize the slashes for it.
	 *
	 * @return void
	 */
	protected function set_request_url() {
		$this-&gt;request_url = $this-&gt;get_request_uri();
	}

	/**
	 * Finds the URL in the redirects.
	 *
	 * @param string $url The needed URL.
	 *
	 * @return bool|string The found url or false if not found.
	 */
	protected function find_url( $url ) {
		$redirect_url = $this-&gt;search( $url );
		if ( ! empty( $redirect_url ) ) {
			return $redirect_url;
		}

		return $this-&gt;find_url_fallback( $url );
	}

	/**
	 * Searches for the given URL in the redirects array.
	 *
	 * @param string $url The URL to search for.
	 *
	 * @return string|bool The found url or false if not found.
	 */
	protected function search( $url ) {
		if ( ! empty( $this-&gt;redirects[ $url ] ) ) {
			return $this-&gt;redirects[ $url ];
		}

		return false;
	}

	/**
	 * Searches for alternatives with slashes if requested URL isn&#039;t found.
	 *
	 * This will add a slash if there isn&#039;t a slash or it will remove a trailing slash when there isn&#039;t one.
	 *
	 * @todo Discuss: Maybe we should add slashes to all the values we handle instead of using a fallback.
	 *
	 * @param string $url The URL that have to be matched.
	 *
	 * @return bool|string The found url or false if not found.
	 */
	protected function find_url_fallback( $url ) {
		$no_trailing_slash = \rtrim( $url, &#039;/&#039; );

		$checks = [
			&#039;no_trailing_slash&#039; =&gt; $no_trailing_slash,
			&#039;trailing_slash&#039;    =&gt; $no_trailing_slash . &#039;/&#039;,
		];

		foreach ( $checks as $check ) {
			$redirect_url = $this-&gt;search( $check );
			if ( ! empty( $redirect_url ) ) {
				return $redirect_url;
			}
		}

		return false;
	}

	/**
	 * Parses the target URL.
	 *
	 * @param string $target_url The URL to parse. When there isn&#039;t found a scheme, just parse it based on the home URL.
	 *
	 * @return string The parsed url.
	 */
	protected function parse_target_url( $target_url ) {
		if ( $this-&gt;has_url_scheme( $target_url ) ) {
			return $target_url;
		}

		$target_url = $this-&gt;trailingslashit( $target_url );
		$target_url = $this-&gt;format_for_multisite( $target_url );

		return $this-&gt;home_url( $target_url );
	}

	/**
	 * Checks if given url has a scheme.
	 *
	 * @param string $url The url to check.
	 *
	 * @return bool True when url has scheme.
	 */
	protected function has_url_scheme( $url ) {
		$scheme = \wp_parse_url( $url, \PHP_URL_SCHEME );

		return ! empty( $scheme );
	}

	/**
	 * Determines whether the target URL ends with a slash and adds one if necessary.
	 *
	 * @param string $target_url The url to format.
	 *
	 * @return string The url with trailing slash.
	 */
	protected function trailingslashit( $target_url ) {
		// Adds slash to target URL when permalink structure ends with a slash.
		if ( $this-&gt;requires_trailing_slash( $target_url ) ) {
			return \trailingslashit( $target_url );
		}

		return $target_url;
	}

	/**
	 * Formats the target url for the multisite if needed.
	 *
	 * @param string $target_url The url to format.
	 *
	 * @return string The formatted url.
	 */
	protected function format_for_multisite( $target_url ) {
		if ( ! \is_multisite() ) {
			return $target_url;
		}

		$blog_details = \get_blog_details();
		if ( $blog_details &amp;&amp; ! empty( $blog_details-&gt;path ) ) {
			$blog_path = \ltrim( $blog_details-&gt;path, &#039;/&#039; );
			if ( ! empty( $blog_path ) &amp;&amp; \strpos( $target_url, $blog_path ) === 0 ) {
				$target_url = \substr( $target_url, \strlen( $blog_path ) );
			}
		}

		return $target_url;
	}

	/**
	 * Gets the redirect URL by given URL.
	 *
	 * @param string $redirect_url The URL that has to be redirected.
	 *
	 * @return string The redirect url.
	 */
	protected function home_url( $redirect_url ) {
		$redirect_url = $this-&gt;strip_subdirectory( $redirect_url );

		return \home_url( $redirect_url );
	}

	/**
	 * Strips the subdirectory from the given url.
	 *
	 * @param string $url The url to strip the subdirectory from.
	 *
	 * @return string The url with the stripped subdirectory.
	 */
	protected function strip_subdirectory( $url ) {
		return WPSEO_Redirect_Util::strip_base_url_path_from_url( $this-&gt;get_home_url(), $url );
	}

	/**
	 * Returns the URL PATH from the home url.
	 *
	 * @return string|null The url path or null if there isn&#039;t one.
	 */
	protected function get_home_url() {
		return \home_url();
	}

	/**
	 * Sets the hook for setting the template include. This is the file that we want to show.
	 *
	 * @param string $template_to_set The template to look for.
	 *
	 * @return bool True when template should be included.
	 */
	protected function set_template_include_hook( $template_to_set ) {
		$this-&gt;template_file_path = $this-&gt;get_query_template( $template_to_set );
		if ( ! empty( $this-&gt;template_file_path ) ) {
			\add_filter( &#039;template_include&#039;, [ $this, &#039;set_template_include&#039; ] );

			return true;
		}

		return false;
	}

	/**
	 * Wraps the WordPress status_header function.
	 *
	 * @param int    $code        HTTP status code.
	 * @param string $description Optional. A custom description for the HTTP status.
	 *
	 * @return void
	 */
	protected function status_header( $code, $description = &#039;&#039; ) {
		\status_header( $code, $description );
	}

	/**
	 * Returns instance of WP_Query.
	 *
	 * @return WP_Query Instance of WP_Query.
	 */
	protected function get_wp_query() {
		global $wp_query;

		if ( \is_object( $wp_query ) ) {
			return $wp_query;
		}

		return new WP_Query();
	}

	/**
	 * Handles the redirects without a target by setting the needed hooks.
	 *
	 * @param string $redirect_type The type of the redirect.
	 *
	 * @return void
	 */
	protected function handle_redirect_without_target( $redirect_type ) {
		if ( $redirect_type === 410 ) {
			\add_action( &#039;wp&#039;, [ $this, &#039;do_410&#039; ] );
		}

		if ( $redirect_type === 451 ) {
			\add_action( &#039;wp&#039;, [ $this, &#039;do_451&#039; ] );
		}
	}

	/**
	 * Wrapper method for doing the actual redirect.
	 *
	 * @param string $location The path to redirect to.
	 * @param int    $status   Status code to use.
	 *
	 * @return void
	 */
	protected function redirect( $location, $status = 302 ) {
		if ( ! \function_exists( &#039;wp_redirect&#039; ) ) {
			require_once \ABSPATH . &#039;wp-includes/pluggable.php&#039;;
		}

		\wp_redirect( $location, $status, &#039;Yoast SEO Premium&#039; );
		exit;
	}

	/**
	 * Returns whether or not a target URL requires a trailing slash.
	 *
	 * @param string $target_url The target URL to check.
	 *
	 * @return bool True when trailing slash is required.
	 */
	protected function requires_trailing_slash( $target_url ) {
		return WPSEO_Redirect_Util::requires_trailing_slash( $target_url );
	}

	/**
	 * Returns the query template.
	 *
	 * @param string $filename Filename without extension.
	 *
	 * @return string Full path to template file.
	 */
	protected function get_query_template( $filename ) {
		return \get_query_template( $filename );
	}

	/**
	 * Actually handles redirects.
	 *
	 * @return void
	 */
	public function handle_redirects() {
		// Set the requested URL.
		$this-&gt;set_request_url();

		// Check the normal redirects.
		$this-&gt;handle_normal_redirects( $this-&gt;request_url );

		// Check the regex redirects.
		if ( $this-&gt;is_redirected() === false ) {
			$this-&gt;handle_regex_redirects();
		}
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2F.trash%2Fwordpress-seo-premium%2Fsrc%2Finitializers'>⬅ Back to Directory</a>