praiadeseselle/wire/modules/Process/ProcessPageView.module

<?php namespace ProcessWire;

/**
 * ProcessWire Page View Process
 *
 * Enables viewing or Processes, one of the core components in connecting ProcessWire to HTTP.
 * 
 * For more details about how Process modules work, please see: 
 * /wire/core/Process.php 
 * 
 * ProcessWire 3.x, Copyright 2021 by Ryan Cramer
 * https://processwire.com
 *
 * @method string execute($internal = true)
 * @method string executeExternal()
 * @method ready(array $data = array())
 * @method finished(array $data = array())
 * @method failed(\Exception $e, $reason = '', $page = null, $url = '')
 * @method sendFile($page, $basename)
 * @method string pageNotFound($page, $url, $triggerReady = false, $reason = '', \Exception $e = null)
 * @method string|bool|array|Page pathHooks($path, $out)
 *
 */
class ProcessPageView extends Process {

	public static function getModuleInfo() {
		return array(
			'title' => __('Page View', __FILE__), // getModuleInfo title
			'summary' => __('All page views are routed through this Process', __FILE__), // getModuleInfo summary 
			'version' => 104, 
			'permanent' => true, 
			'permission' => 'page-view',
		);
	}

	/**
	 * Response types 
	 *
	 */
	const responseTypeError = 0;
	const responseTypeNormal = 1; 
	const responseTypeAjax = 2; 
	const responseTypeFile = 4; 
	const responseTypeRedirect = 8; 
	const responseTypeExternal = 16; 
	const responseTypeNoPage = 32;
	const responseTypePathHook = 64;

	/**
	 * Response type (see response type codes above)
	 *
	 */
	protected $responseType = 1; 

	/**
	 * URL that should be redirected to for this request
 	 * 
	 * Set by other methods in this class, and checked by the execute method before rendering. 
 	 *
	 */
	protected $redirectURL = '';

	/**
	 * True if any redirects should be delayed until after API ready() has been issued
	 * 
	 */
	protected $delayRedirects = false; 

	/**
	 * Sanitized path that generated this request
 	 * 
	 * Set by the getPage() method and passed to the pageNotFound function.
 	 *
	 */
	protected $requestPath = '';

	/**
	 * Unsanitized URL from $_SERVER['REQUEST_URI']
	 * 
	 * @var string
	 * 
	 */
	protected $dirtyURL = '';

	/**
	 * Requested filename, if URL in /path/to/page/-/filename.ext format
	 *
	 */
	protected $requestFile = '';

	/**
	 * Page number found in the URL or null if not found
	 * 
	 */
	protected $pageNum = null;

	/**
	 * Page number prefix found in the URL or null if not found
	 *
	 */
	protected $pageNumPrefix = null;

	/**
	 * @var Page|null
	 * 
	 */
	protected $http404Page = null;

	/**
	 * Return value from first iteration of pathHooks() method (when applicable)
	 * 
	 * @var mixed 
	 * 
	 */
	protected $pathHooksReturnValue = false;

	/**
	 * Construct
	 * 
	 */
	public function __construct() {
		// no parent call intentional
	}

	/**
	 * Init
	 * 
	 */
	public function init() {
	
		$this->dirtyURL = isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : '';
		if(empty($this->dirtyURL) && !empty($_SERVER['QUERY_STRING'])) $this->dirtyURL = '?' . $_SERVER['QUERY_STRING'];

		// check if there is an 'it' GET variable present in the request URL query string, which we don't want here
		if(isset($_GET['it']) && (strpos($this->dirtyURL, '?it=') !== false || strpos($this->dirtyURL, '&it='))) {
			// force to use path in request url rather than contents of 'it' var
			list($it,) = explode('?', $this->dirtyURL);
			$rootURL = $this->wire('config')->urls->root;
			if(strlen($rootURL) > 1 && strpos($it, $rootURL) === 0) $it = substr($it, strlen($rootURL)-1);
			$it = str_replace('index.php', '', $it);
			$_GET['it'] = $it;
		}
		
		// no parent call intentional
	}

	/**
	 * Retrieve a page, check access, and render
	 * 
	 * @param bool $internal True if request should be internally processed. False if PW is bootstrapped externally. 
	 * @return string Output of request
 	 *
	 */
	public function ___execute($internal = true) {
	
		if(!$internal) return $this->executeExternal();

		$this->responseType = self::responseTypeNormal;
		$config = $this->wire()->config; 
		$timerKey = $config->debug ? 'ProcessPageView.getPage()' : ''; 
		if($config->usePoweredBy !== null) header('X-Powered-By:' . ($config->usePoweredBy ? ' ProcessWire CMS' : ''));
		
		$this->wire()->pages->setOutputFormatting(true); 
		
		if($timerKey) Debug::timer($timerKey); 
		$page = $this->getPage();
		if($timerKey) Debug::saveTimer($timerKey, ($page && $page->id ? $page->path : '')); 
		
		if(!$page || !$page->id) return $this->renderNoPage();
		
		return $this->renderPage($page);
	}

	/**
	 * Render Page
	 * 
	 * @param Page $page
	 * @return bool|mixed|string
	 * @throws WireException
	 * @since 3.0.173
	 * 
	 */
	protected function renderPage(Page $page) {
		
		$config = $this->wire()->config;
		$page->setOutputFormatting(true);
		$_page = $page;
		
		$page = $this->checkAccess($page);

		if(!$page || $_page->id == $config->http404PageID) {
			$s = 'access not allowed';
			$e = new Wire404Exception($s, Wire404Exception::codePermission);
			return $this->pageNotFound($_page, $this->requestPath, true, $s, $e);
		}

		if(!$this->delayRedirects) {
			$this->checkProtocol($page);
			if($this->redirectURL) $this->redirect($this->redirectURL);
		}

		$this->wire('page', $page);
		$this->ready();
		$page = $this->wire('page'); // in case anything changed it

		if($this->delayRedirects) {
			$this->checkProtocol($page);
			if($this->redirectURL) $this->redirect($this->redirectURL);
		}

		try {

			if($this->requestFile) {

				$this->responseType = self::responseTypeFile;
				$this->wire()->setStatus(ProcessWire::statusDownload, array('downloadFile' => $this->requestFile));
				$this->sendFile($page, $this->requestFile);

			} else {

				$contentType = $this->contentTypeHeader($page, true);
				$this->wire()->setStatus(ProcessWire::statusRender, array('contentType' => $contentType));
				if($config->ajax) $this->responseType = self::responseTypeAjax;
				
				return $page->render();
			}

		} catch(Wire404Exception $e) {
			// 404 exception
			TemplateFile::clearAll();
			return $this->renderNoPage(array(
				'reason404' => '404 thrown during page render',
				'exception404' => $e, 
				'page' => $page, 
				'ready' => true, // let it know ready state already executed
			));

		} catch(\Exception $e) {
			// other exception (re-throw non 404 exceptions)
			$this->responseType = self::responseTypeError;
			$this->failed($e, "Thrown during page render", $page);
			throw $e; 
		}

		return '';
	}

	/**
	 * Render when no page mapped to request URL
	 * 
	 * @param array $options
	 * @return array|bool|false|string
	 * @throws WireException
	 * @since 3.0.173
	 * 
	 */
	protected function renderNoPage(array $options = array()) {
		
		$defaults = array(
			'allow404' => true, // allow 404 to be thrown?
			'reason404' => 'Requested URL did not resolve to a Page',
			'exception404' => null, 
			'ready' => false, // are we executing from the API ready state?
			'page' => $this->http404Page(), // potential Page object (default is 404 page)
		);
		
		$options = count($options) ? array_merge($defaults, $options) : $defaults;
		$config = $this->wire()->config;
		$hooks = $this->wire()->hooks;
		$input = $this->wire()->input; 
		$requestPath = $this->requestPath;
		$setPageNum = 0;
		$pageNumSegment = '';
		$page = null;
		$out = false;
		
		$this->setResponseType(self::responseTypeNoPage);
		
		if($this->pageNum > 0 && $this->pageNumPrefix !== null) {
			// there is a pagination segment present in the request path
			$slash = substr($requestPath, -1) === '/' ? '/' : '';
			$requestPath = rtrim($requestPath, '/');
			$pageNumSegment = $this->pageNumPrefix . $this->pageNum;
			if(substr($requestPath, -1 * strlen($pageNumSegment)) === $pageNumSegment) {
				// remove pagination segment from request path
				$requestPath = substr($requestPath, 0, -1 * strlen($pageNumSegment));
				$setPageNum = $this->pageNum;
				// disallow specific "/page1" in URL as it is implied by the lack of pagination segment
				if($setPageNum === 1) $this->redirect($config->urls->root . ltrim($requestPath, '/'));
				// enforce no trailing slashes for pagination numbers
				if($slash) $this->redirect($config->urls->root . ltrim($requestPath, '/') . $pageNumSegment);
				$input->setPageNum($this->pageNum);
			} else {
				// not a pagination segment
				// add the slash back to restore requestPath
				$requestPath .= $slash;
				$pageNumSegment = '';
			}
		}
		
		if(!$options['ready']) $this->wire('page', $options['page']);

		// run up to 2 times, once before ready state and once after
		for($n = 1; $n <= 2; $n++) {
			
			// only run once if already in ready state
			if($options['ready']) $n = 2;

			// call ready() on 2nd iteration only, allows for ready hooks to set $page
			if($n === 2 && !$options['ready']) $this->ready();
			
			if(!$hooks->hasPathHooks()) continue;

			$this->setResponseType(self::responseTypePathHook);
			
			try {
				$out = $this->pathHooks($requestPath, $out);
			} catch(Wire404Exception $e) {
				$out = false;
			}
		
			// allow for pathHooks() $event->return to persist between init and ready states
			// this makes it possible for ready() call to examine $event->return from init() call
			// in case it wants to concatenate it or something
			if($n === 1) $this->pathHooksReturnValue = $out;

			if(is_object($out) && $out instanceof Page) {
				// hook returned Page object to set as page to render
				$page = $out;
				$out = true;
			} else {
				// check if hooks changed $page API variable instead
				$page = $this->wire()->page;
			}

			// first hook that determines the $page wins
			if($page && $page->id && $page->id !== $options['page']->id) break;

			$this->setResponseType(self::responseTypeNoPage);
		}
	
		// did a path hook require a redirect for trailing slash (vs non-trailing slash)?
		$redirect = $hooks->getPathHookRedirect();
		if($redirect) {
			// path hook suggests a redirect for proper URL format
			$url = $config->urls->root . ltrim($redirect, '/');
			// if present, add pagination segment back into URL
			if($pageNumSegment) $url = rtrim($url, '/') . "/$pageNumSegment";
			$this->redirect($url);
		}
		
		$this->pathHooksReturnValue = false; // no longer applicable once this line reached
		$hooks->allowPathHooks(false); // no more path hooks allowed
		
		if($page && $page->id && $page instanceof Page && $page->id !== $options['page']->id) {
			// one of the path hooks set the page
			$this->wire('page', $page);
			return $this->renderPage($page); 
		}

		if($out === false) {
			// hook failed to handle request
			if($setPageNum > 1) $input->setPageNum(1);
			if($options['allow404']) {
				$page = $options['page'];
				// hooks to pageNotFound() method may expect NullPage rather than 404 page
				if($page->id == $config->http404PageID) $page = $this->wire(new NullPage()); 
				$out = $this->pageNotFound($page, $this->requestPath, false, $options['reason404'], $options['exception404']);
			} else {
				$out = false;
			}
			
		} else if($out === true) {
			// hook silently handled the request
			$out = '';
			
		} else if(is_array($out)) {
			// hook returned array to convert to JSON
			$jsonFlags = JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES;
			$contentTypes = $config->contentTypes;
			if(isset($contentTypes['json'])) header("Content-Type: $contentTypes[json]");
			$out = json_encode($out, $jsonFlags);
		}
		
		return $out;
	}

	/**
	 * Get and optionally send the content-type header
	 * 
	 * @param Page $page
	 * @param bool $send
	 * @return string
	 * 
	 */
	protected function contentTypeHeader(Page $page, $send = false) {
		
		$config = $this->wire()->config;
		$contentType = $page->template->contentType;
		
		if(!$contentType) return '';
		
		if(strpos($contentType, '/') === false) {
			if(isset($config->contentTypes[$contentType])) {
				$contentType = $config->contentTypes[$contentType];
			} else {
				$contentType = '';
			}
		}
		
		if($contentType && $send) header("Content-Type: $contentType");
		
		return $contentType;
	}

	/**
	 * Method executed when externally bootstrapped
	 * 
	 * @return string blank string
	 * 
	 */
	public function ___executeExternal() {
		$this->setResponseType(self::responseTypeExternal);
		$config = $this->wire('config'); 
		$config->external = true; 
		if($config->externalPageID) {
			$page = $this->wire('pages')->get((int) $config->externalPageID); 
		} else {
			$page = $this->wire('pages')->newNullPage();
		}
		$this->wire('page', $page);
		$this->ready();
		$this->wire()->setStatus(ProcessWire::statusRender, array('contentType' => 'external'));
		return '';
	}

	/**
	 * Hook called when the $page API var is ready, and before the $page is rendered. 
	 * 
	 * @param array $data
	 *
	 */
	public function ___ready(array $data = array()) { 
		$this->wire()->setStatus(ProcessWire::statusReady, $data);
	}

	/**
	 * Hook called with the pageview has been finished and output has been sent. Note this is called in /index.php.
	 * 
	 * @param array $data
	 *	
 	 */
	public function ___finished(array $data = array()) { 
		$this->wire()->setStatus(ProcessWire::statusFinished, $data);
	}

	/**
	 * Hook called when the pageview failed to finish due to an Exception or Error.
	 *
	 * Sends a copy of the throwable that occurred.
	 * 
	 * @param \Throwable $e Exception or Error
	 * @param string $reason
	 * @param Page|null $page
	 * @param string $url
	 *	
 	 */
	public function ___failed($e, $reason = '', $page = null, $url = '') { 
		$this->wire()->setStatusFailed($e, $reason, $page, $url); 
	}

	/**
	 * Get the requested page and populate it with identified urlSegments or page numbers
 	 *
	 * @return Page|null
	 *
	 */
	protected function getPage() {

		$config = $this->wire()->config;
		$sanitizer = $this->wire()->sanitizer;
		
		// force redirect to actual page URL? (if different from request URL)
		$forceRedirect = false;
	
		// did URL end with index.php|htm|html? If so we might redirect if a page matches without it. 
		$hasIndexFile = false;

		// get the requested path
		$it = $this->getPageRequestPath();
		if($it === false) return null;
	
		// check if there are index files in the request
		if(strpos($it, '/index.') !== false && preg_match('{/index\.(php|html?)$}', $it, $matches)) {
			// if request is to index.php|htm|html, make note of it to determine if we can redirect later
			$hasIndexFile = true; 
		} else if(strpos($this->dirtyURL, 'index.php') !== false && strpos($it, 'index.php') === false) {
			// if request contains index.php and the request path ($it) does not, force redirect to correct version
			if(preg_match('!/index\.php$!', parse_url($this->dirtyURL, PHP_URL_PATH))) $forceRedirect = true; 
		}
	
		// check if request is for a secure pagefile
		if($this->pagefileSecurePossible($it)) {
			$page = $this->checkRequestFile($it);
			if(is_object($page)) {
				$this->responseType = self::responseTypeFile;
				return $page; // Page or NullPage
			}
		}

		// check for pagination segment
		if($this->checkPageNumPath($it)) {
			// path has a pagination prefix and number in it,
			// populated to $this->pageNumPrefix and $this->pageNumPath
			$page = null;
		} else {
			// no pagination number, see if it already resolves to a Page
			$page = $this->pagesGet($it);
		}

		if($page && $page->id) {
			// path resolves to page with NO pageNum or urlSegments present
			if($forceRedirect) {
				// index.php in URL redirect to actual page URL
				$this->redirectURL = $page->url; 
			} else if($page->id > 1) {
				// trailing slash vs. non trailing slash, enforced if not homepage 
				// redirect to proper trailed slash version if incorrect version is present.
				// note: this section only executed if no URL segments or page numbers were present
				$hasTrailingSlash = substr($it, -1) == '/';
				$slashUrls = $page->template->slashUrls;
				if((!$hasTrailingSlash && $slashUrls !== 0) || ($hasTrailingSlash && $slashUrls === 0)) {
					$this->redirectURL = $page->url;
				}
			}
			return $page; 
		}

		// check for globally unique page which can redirect
		$name = trim($it, '/');
		if($name && strpos($name, '/') === false && $sanitizer->pageNameUTF8($name) === $name) {
			$page = $this->pagesGet($name, 'name', 'status=' . Page::statusUnique); 
			// if found, redirect to globally unique page
			if($page && $page->viewable()) $this->redirectURL = $page->url;
		}

		// populate request path to class as other methods will now use it
		$this->requestPath = $it;
		
		// check if path with URL segments can resolve to a page
		$urlSegments = array();
		if(!$page) $page = $this->getPageUrlSegments($it, $urlSegments);
	
		// if URL segments and/or page numbers are present and not allowed then abort
		if($page && count($urlSegments) && !$this->checkUrlSegments($urlSegments, $page)) {
			// found URL segments were checked and found not to be allowed here
			if($hasIndexFile && count($urlSegments) === 1) {
				// index.php|htm|html segments if not used by page can redirect to URL without it
				$forceRedirect = true; 
			} else {
				// page with invalid URL segments becomes a 404
				$page = null;
			}
		}

		// if no page found for guest user, check if path was in admin and map to admin root
		if(!$page && $this->wire()->user->isGuest()) {
			// this ensures that no admin requests resolve to a 404 and instead show login form
			$adminPath = substr($config->urls->admin, strlen($config->urls->root)-1); 
			if(strpos($this->requestPath, $adminPath) === 0) {
				$page = $this->wire()->pages->get($config->adminRootPageID);
			}
			$forceRedirect = false;
		}

		if($forceRedirect && $page && !$this->redirectURL) {
			$this->redirectURL = $page->url;
		}
		
		return $page; 
	}

	/**
	 * Given a path with URL segments, get matching Page and populate given $urlSegments array
	 * 
	 * @param string $path
	 * @param array $urlSegments
	 * @return null|Page
	 * 
	 */
	protected function getPageUrlSegments($path, array &$urlSegments) {
		
		$numSegments = 0;
		$maxSegments = $this->wire()->config->maxUrlSegments; 
		$maxSegments = $maxSegments === null ? 4 : (int) $maxSegments;
		$page = null;

		// if the page isn't found, then check if a page one path level before exists
		// this loop allows for us to have both a urlSegment and a pageNum
		while(!$page && $numSegments < $maxSegments) {
			$path = rtrim($path, '/');
			$pos = strrpos($path, '/') + 1;
			$urlSegment = substr($path, $pos);
			$urlSegments[$numSegments] = $urlSegment;
			$path = substr($path, 0, $pos); // $path no longer includes the urlSegment
			$page = $this->pagesGet($path);
			$numSegments++;
		}
	
		return $page;
	}

	/**
	 * Get the requested path
	 * 
	 * @return bool|string Return false on fail or path on success
	 * 
	 */
	protected function getPageRequestPath() {
		
		$config = $this->wire()->config;
		$sanitizer = $this->wire()->sanitizer;
		
		/** @var string $shit Dirty URL */
		/** @var string $it Clean URL */

		if(isset($_GET['it'])) {
			// normal request
			$shit = trim($_GET['it']);

		} else if(isset($_SERVER['REQUEST_URI'])) {
			// abnormal request, something about request URL made .htaccess skip it, or index.php called directly
			$rootUrl = $config->urls->root;
			$shit = trim($_SERVER['REQUEST_URI']);
			if(strpos($shit, '?') !== false) list($shit,) = explode('?', $shit, 2);
			if($rootUrl != '/') {
				if(strpos($shit, $rootUrl) === 0) {
					// remove root URL from request
					$shit = substr($shit, strlen($rootUrl) - 1);
				} else {
					// request URL outside of our root directory
					return false;
				}
			}
		} else {
			$shit = '/';
		}

		if($shit === '/') {
			$it = '/';
		} else {
			$it = preg_replace('{[^-_./a-zA-Z0-9]}', '', $shit); // clean
		}

		unset($_GET['it']);

		if($shit !== $it) {
			// sanitized URL does not match requested URL
			if($config->pageNameCharset == 'UTF8') {
				// test for extended page name URL
				$it = $sanitizer->pagePathNameUTF8($shit);
			}
			if($shit !== $it) {
				// if still does not match then fail
				return false;
			}
		}
		
		$maxUrlDepth = $config->maxUrlDepth;
		if($maxUrlDepth > 0 && substr_count($it, '/') > $config->maxUrlDepth) return false;

		if(!isset($it[0]) || $it[0] != '/') $it = "/$it";
		if(strpos($it, '//') !== false) return false;
		
		return $it;
	}

	/**
	 * Check if given path has a page/pagination number and return it if so (return 0 if not)
	 * 
	 * @param string $path
	 * @return int
	 * 
	 */
	protected function checkPageNumPath($path) {

		$hasPrefix = false;
		$pageNumUrlPrefixes = $this->pageNumUrlPrefixes();
		
		foreach($pageNumUrlPrefixes as $prefix) {
			if(strpos($path, '/' . $prefix) !== false) {
				$hasPrefix = true;
				break;
			}
		}
		
		if($hasPrefix && preg_match('{/(' . implode('|', $pageNumUrlPrefixes) . ')(\d+)/?$}', $path, $matches)) {
			// URL contains a page number, but we'll let it be handled by the checkUrlSegments function later
			$this->pageNumPrefix = $matches[1];
			$this->pageNum = (int) $matches[2];
			return $this->pageNum;
		}

		return 0;
	}

	/**
	 * Check if the requested URL is to a secured page file
	 *
	 * This function sets $this->requestFile when it finds one.
	 * Returns Page when a pagefile was found and matched to a page.
	 * Returns NullPage when request should result in a 404. 
	 * Returns true, and updates $it, when pagefile was found using old/deprecated method.
	 * Returns false when none found.
	 *
	 * @param string $it Request URL
	 * @return bool|Page|NullPage 
	 *
	 */
	protected function checkRequestFile(&$it) {
	
		$config = $this->wire()->config;
		$pages = $this->wire()->pages;
		
		// request with url to root (applies only if site runs from subdirectory)
		$itRoot = rtrim($config->urls->root, '/') . $it;

		// check for secured filename, method 1: actual file URL, minus leading "." or "-"
		if(strpos($itRoot, $config->urls->files) === 0) {
			// request is for file in site/assets/files/...
			$idAndFile = substr($itRoot, strlen($config->urls->files));
			
			// matching in $idAndFile: 1234/file.jpg, 1/2/3/4/file.jpg, 1234/subdir/file.jpg, 1/2/3/4/subdir/file.jpg, etc. 
			if(preg_match('{^(\d[\d\/]*)/([-_a-zA-Z0-9][-_./a-zA-Z0-9]+)$}', $idAndFile, $matches) && strpos($matches[2], '.')) {
				// request is consistent with those that would match to a file
				$idPath = trim($matches[1], '/');
				$file = trim($matches[2], '.');
				
				if(!strpos($file, '.')) return $pages->newNullPage();
				
				if(!ctype_digit("$idPath")) {
					// extended paths where id separated by slashes, i.e. 1/2/3/4
					if($config->pagefileExtendedPaths) {
						// allow extended paths
						$idPath = str_replace('/', '', $matches[1]); 
						if(!ctype_digit("$idPath")) return $pages->newNullPage();
					} else {
						// extended paths not allowed
						return $pages->newNullPage();
					}
				}
				
				if(strpos($file, '/') !== false) {
					// file in subdirectory (for instance ProDrafts uses subdirectories for draft files)
					list($subdir, $file) = explode('/', $file, 2);
					
					if(strpos($file, '/') !== false) {
						// there is more than one subdirectory, which we do not allow
						return $pages->newNullPage();
						
					} else if(strpos($subdir, '.') !== false || strlen($subdir) > 128) {
						// subdirectory has a "." in it or subdir length is too long
						return $pages->newNullPage();
						
					} else if(!preg_match('/^[a-zA-Z0-9][-_a-zA-Z0-9]+$/', $subdir)) {
						// subdirectory not in expected format  
						return $pages->newNullPage();
					}
					
					$file = trim($file, '.');
					$this->requestFile = "$subdir/$file";
					
				} else {
					// file without subdirectory
					$this->requestFile = $file;
				}
				
				return $pages->get((int) $idPath); // Page or NullPage
				
			} else {
				// request was to something in /site/assets/files/ but we don't recognize it
				// tell caller that this should be a 404
				return $pages->newNullPage();
			}
		}

		// check for secured filename: method 2 (deprecated), used only if $config->pagefileUrlPrefix is defined
		$filePrefix = $config->pagefileUrlPrefix;
		if($filePrefix && strpos($it, '/' . $filePrefix) !== false) { 
			if(preg_match('{^(.*/)' . $filePrefix . '([-_.a-zA-Z0-9]+)$}', $it, $matches) && strpos($matches[2], '.')) {
				$it = $matches[1];
				$this->requestFile = $matches[2]; 
				return true; 
			}
		} 

		return false;
	}

	/**
	 * Identify and populate URL segments and page numbers
	 *
	 * @param array $urlSegments URL segments as found in getPage()
	 * @param Page $page
	 * @return bool Returns false if URL segments found and aren't allowed
	 *
	 */
	protected function checkUrlSegments(array $urlSegments, Page $page) {

		if(!count($urlSegments)) return true; 
		
		$input = $this->wire()->input;
		$lastSegment = reset($urlSegments);
		$urlSegments = array_reverse($urlSegments); 
		$pageNum = 1; 
		$template = $page->template;

		// check if the last urlSegment is setting a page number and that page numbers are allowed
		if(!is_null($this->pageNum) && $lastSegment === "$this->pageNumPrefix$this->pageNum" && $template->allowPageNum) {
			// meets the requirements for a page number: last portion of URL and starts with 'page'
			$pageNum = (int) $this->pageNum; 
			if($pageNum < 1) $pageNum = 1;
			if($pageNum > 1 && !$this->wire()->user->isLoggedin()) {
				$maxPageNum = $this->wire()->config->maxPageNum; 
				if(!$maxPageNum) $maxPageNum = 999;
				if($pageNum > $maxPageNum) return false; 
			}
			$page->setQuietly('pageNum', $pageNum); // backwards compatibility
			$input->setPageNum($pageNum); 
			array_pop($urlSegments); 
		} 

		// return false if URL segments aren't allowed with this page template
		if($template->name !== 'admin' && count($urlSegments)) { 
			if(!$this->isAllowedUrlSegment($page, $urlSegments)) return false;
		}	

		// now set the URL segments to the $input API variable
		$cnt = 1; 
		foreach($urlSegments as $urlSegment) {
			if($cnt == 1) $page->setQuietly('urlSegment', $urlSegment); // backwards compatibility
			$input->setUrlSegment($cnt, $urlSegment);
			$cnt++;
		}
	
		if($pageNum > 1 || count($urlSegments)) {
			$hasTrailingSlash = substr($this->requestPath, -1) == '/';
			// $url=URL with urlSegments and no trailing slash
			// $url = rtrim(rtrim($page->url, '/') . '/' . $this->input->urlSegmentStr, '/');
			$redirectPath = null;
			if($pageNum > 1 && $template->slashPageNum) {
				if($template->slashPageNum == 1 && !$hasTrailingSlash) {
					// enforce trailing slash on page numbers
					//$this->redirectURL = "$url/$this->pageNumPrefix$pageNum/";
					$redirectPath = "/$this->pageNumPrefix$pageNum/";
				} else if($template->slashPageNum == -1 && $hasTrailingSlash) {
					// enforce NO trailing slash on page numbers
					// $this->redirectURL =  "$url/$this->pageNumPrefix$pageNum";
					$redirectPath = "/$this->pageNumPrefix$pageNum";
				}
				
			} else if(count($urlSegments) && $template->slashUrlSegments) {
				if($template->slashUrlSegments == 1 && !$hasTrailingSlash) {
					// enforce trailing slash with URL segments
					// $this->redirectURL = "$url/";
					$redirectPath = "/";
					
				} else if($template->slashUrlSegments == -1 && $hasTrailingSlash) {
					// enforce no trailing slash with URL segments
					// $this->redirectURL = $url;
					$redirectPath = "";
				}
			}
			
			if($redirectPath !== null) {
				// redirect will occur to a proper slash format
				$modules = $this->wire()->modules;
				if($modules->isInstalled('LanguageSupportPageNames')) {
					// ensure that LanguageSupportPageNames reaches a ready() state, since 
					// it can modify the output of $page->url (if installed)
					$this->wire('page', $page);
					$modules->get('LanguageSupportPageNames')->ready();
				}
				$this->redirectURL = rtrim(rtrim($page->url, '/') . '/' . $input->urlSegmentStr, '/') . $redirectPath;
			}
		}

		return true; 
	}

	/**
	 * Is the given URL segment allowed according to the page template's settings?
	 *
	 * @param Page $page
	 * @param string|array $segment May be a single segment or path of segments
	 * @return bool
	 *
	 */
	protected function isAllowedUrlSegment(Page $page, $segment) {

		$urlSegments = $page->template->urlSegments();

		if(is_array($urlSegments)) {
			// only specific URL segments are allowed
			if(is_array($segment)) $segment = implode('/', $segment);
			$segment = trim($segment, '/');
			$allowed = false;
			foreach($urlSegments as $allowedSegment) {
				if(strpos($allowedSegment, 'regex:') === 0) {
					$regex = '{' . trim(substr($allowedSegment, 6)) . '}';
					$allowed = preg_match($regex, $segment);

				} else if($segment === $allowedSegment) {
					$allowed = true;
				}
				if($allowed) break;
			}
			return $allowed;

		} else if($urlSegments > 0) {
			// all URL segments are allowed
			return true;

		} else {
			// no URL segments are allowed
			return false;
		}

	}

	/**
	 * Check that the current user has access to the page and return it 
	 *
	 * If the user doesn't have access, then a login Page or NULL (for 404) is returned instead. 
	 *
	 * @param Page $page
	 * @return Page|null
	 *
	 */
	protected function checkAccess($page) {

		$user = $this->wire()->user;
	
		if($this->requestFile) {
			// if a file was requested, we still allow view even if page doesn't have template file
			if($page->viewable($this->requestFile) === false) return null;
			if($page->viewable(false)) return $page; 
			// if($page->editable()) return $page;
			if($this->checkAccessDelegated($page)) return $page; 
			if($page->status < Page::statusUnpublished && $user->hasPermission('page-view', $page)) return $page;
			
		} else if($page->viewable()) {
			return $page;
			
		} else if($page->parent_id && $page->parent->template->name === 'admin' && $page->parent->viewable()) {
			// check for special case in admin when Process::executeSegment() collides with page name underneath
			// example: a role named "edit" is created and collides with ProcessPageType::executeEdit()
			$input = $this->wire()->input;
			if($user->isLoggedin() && $page->editable() && !strlen($input->urlSegmentStr())) {
				$input->setUrlSegment(1, $page->name);
				return $page->parent;
			}
		}

		$accessTemplate = $page->getAccessTemplate();
		$redirectLogin = $accessTemplate ? $accessTemplate->redirectLogin : false;
	
		// if we won’t be presenting a login form then $page converts to null (404)
		if(!$redirectLogin) return null;
		
		$config = $this->wire()->config;
		$disallowIDs = array($config->trashPageID); // don't allow login redirect for these pages
		$loginRequestURL = $this->redirectURL;
		$loginPageID = $config->loginPageID;
		$requestPage = $page;
		$session = $this->wire()->session;
		$input = $this->wire()->input;
		$ns = 'ProcessPageView';
		
		if($page->id && in_array($page->id, $disallowIDs)) {
			// don't allow login redirect when matching disallowIDs
			$page = null;
			
		} else if(ctype_digit("$redirectLogin")) {
			// redirect login provided as a page ID
			$redirectLogin = (int) $redirectLogin;
			// if given ID 1 then this maps to the admin login page
			if($redirectLogin === 1) $redirectLogin = $loginPageID; 
			$page = $this->pages->get($redirectLogin); 
			
		} else {
			// redirect login provided as a URL, optionally with an {id} tag for requested page ID
			$redirectLogin = str_replace('{id}', $page->id, $redirectLogin); 
			$this->redirectURL = $redirectLogin;
		}
		
		if(empty($loginRequestURL)) {
			$loginRequestURL = $session->getFor($ns, 'loginRequestURL');
		}
		
		// in case anything after login needs to know the originally requested page/URL
		if(empty($loginRequestURL) && $page && $requestPage && $requestPage->id) { 
			if($requestPage->id != $loginPageID && !$input->get('loggedout')) {
				$loginRequestURL = $input->url(array('page' => $requestPage));
				if(!empty($_GET)) {
					$queryString = $input->queryStringClean(array(
						'maxItems' => 10,
						'maxLength' => 500,
						'maxNameLength' => 20,
						'maxValueLength' => 200,
						'sanitizeName' => 'fieldName',
						'sanitizeValue' => 'name',
						'entityEncode' => false,
					));
					if(strlen($queryString)) $loginRequestURL .= "?$queryString";
				}
				$session->setFor($ns, 'loginRequestPageID', $requestPage->id);
				$session->setFor($ns, 'loginRequestURL', $loginRequestURL);
			}
		}

		return $page; 
	}

	/**
	 * Check access to a delegated page (like a repeater)
	 * 
	 * Note: this should move to PagePermissions.module or FieldtypeRepeater.module 
	 * if a similar check is needed somewhere else in the core.
	 * 
	 * @param Page $page
	 * @return Page|null|bool
	 * 
	 */
	protected function checkAccessDelegated(Page $page) {
		if(strpos($page->template->name, 'repeater_') == 0) {
			if(!$this->wire('modules')->isInstalled('FieldtypeRepeater')) return false;
			$fieldName = substr($page->template->name, strpos($page->template->name, '_') + 1); // repeater_(fieldName)
			if(!$fieldName) return false;
			$field = $this->wire('fields')->get($fieldName);
			if(!$field) return false;
			$forPageID = substr($page->parent->name, strrpos($page->parent->name, '-') + 1); // for-page-(id)
			$forPage = $this->wire('pages')->get((int) $forPageID);
			// delegate viewable check to the page the repeater lives on
			if($forPage->id) {
				if($forPage->viewable($field)) return $page;
				if(strpos($forPage->template->name, 'repeater_') === 0) {
					// go recursive for nested repeaters
					$forPage = $this->checkAccessDelegated($forPage); 	
					if($forPage && $forPage->id) return $forPage; 
				}
			}
		}
		return null;
	}

	/**
	 * If the template requires a different protocol than what is here, then redirect to it.
	 *
	 * This method just silently sets the $this->redirectURL var if a redirect is needed. 
	 * Note this does not work if GET vars are present in the URL -- they will be lost in the redirect.
	 *
	 * @param Page $page
	 *
	 */
	protected function checkProtocol($page) {
	
		/** @var Config $config */
		$config = $this->wire('config');
		$requireHTTPS = $page->template->https;
		if($requireHTTPS == 0 || $config->noHTTPS) return; // neither HTTP or HTTPS required
		
		$isHTTPS = $config->https; 
		$scheme = '';

		if($requireHTTPS == -1 && $isHTTPS) {
			// HTTP required: redirect to HTTP non-secure version
			$scheme = "http";

		} else if($requireHTTPS == 1 && !$isHTTPS) {
			// HTTPS required: redirect to HTTPS secure version
			$scheme = "https";
		}
		
		if(!$scheme) return;
		
		if($this->redirectURL) {
			if(strpos($this->redirectURL, '://') !== false) {
				$url = str_replace(array('http://', 'https://'), "$scheme://", $this->redirectURL);
			} else {
				$url = "$scheme://$config->httpHost$this->redirectURL";
			}
		} else {
			$url = "$scheme://$config->httpHost$page->url";
		}
		$input = $this->wire('input'); 
	
		if($this->redirectURL) {
			// existing redirectURL will already have segments/page numbers as needed
			
		} else {
			$urlSegmentStr = $input->urlSegmentStr;
			if(strlen($urlSegmentStr) && $page->template->urlSegments) {
				$url = rtrim($url, '/') . '/' . $urlSegmentStr;
				if($page->template->slashUrlSegments) {
					// use defined setting for trailing slash
					if($page->template->slashUrlSegments == 1) $url .= '/';
				} else {
					// use whatever the request came with	
					if(substr($this->requestPath, -1) == '/') $url .= '/';
				}
			}

			$pageNum = $input->pageNum;
			if($pageNum > 1 && $page->template->allowPageNum) {
				$prefix = $this->pageNumPrefix ? $this->pageNumPrefix : $this->wire('config')->pageNumUrlPrefix;
				if(!$prefix) $prefix = 'page';
				$url = rtrim($url, '/') . "/$prefix$pageNum";
				if($page->template->slashPageNum) {
					// defined setting for trailing slash	
					if($page->template->slashPageNum == 1) $url .= '/';
				} else {
					// use whatever setting the URL came with
					if(substr($this->requestPath, '-1') == '/') $url .= '/';
				}
			}
		}
		
		$this->redirectURL = $url;
	}
	
	/**
	 * Get Page from $pages via path (or other property) or return null if it does not exist
	 *
	 * @param string $value Value to match
	 * @param string $property Property being matched (default='path')
	 * @param string $selector Additional selector to apply (default='status<9999999'); 
	 * @return null|Page
	 * @since 3.0.168
	 *
	 */
	protected function pagesGet($value, $property = 'path', $selector = 'status<9999999') {
		if(!is_int($value)) $value = $this->wire()->sanitizer->selectorValue($value, array(
			'maxLength' => 2048,
			'maxBytes' => 6144,
			'allowArray' => false,
			'allowSpace' => false,
			'blacklist' => array(',', "'"),
		));
		$page = $this->wire()->pages->get("$property=$value, $selector");
		return $page->id ? $page : null;
	}
	
	/**
	 * Passthru a file for a non-public page
	 *
	 * If the page is public, then it just does a 301 redirect to the file.
	 * 
	 * @param Page $page
	 * @param string $basename 
	 * @param array $options
	 * @throws Wire404Exception
	 *
	 */
	protected function ___sendFile($page, $basename, array $options = array()) {

		$err = 'File not found';

		if(!$page->hasFilesPath()) {
			throw new Wire404Exception($err, Wire404Exception::codeFile);
		}

		$filename = $page->filesPath() . $basename; 
		
		if(!file_exists($filename)) {
			throw new Wire404Exception($err, Wire404Exception::codeFile);
		}
	
		if(!$page->secureFiles()) {
			// if file is not secured, redirect to it
			// (potentially deprecated, only necessary for method 2 in checkRequestFile)
			$this->redirect($page->filesManager->url() . $basename);
			return;
		}

		// options for WireHttp::sendFile
		$defaults = array('exit' => false, 'limitPath' => $page->filesPath());
		$options = array_merge($defaults, $options);
		
		$this->wire()->files->send($filename, $options);
	}

	/**
	 * Called when a page is not found, sends 404 header, and displays the configured 404 page instead.
	 *
	 * Method is hookable, for instance if you wanted to log 404s. When hooking this method note that it
	 * must be hooked sometime before the ready state. 
	 * 
	 * @param Page|null $page Page that was found if applicable (like if user didn't have permission or $page's template threw the 404). If not applicable then NULL will be given instead.
	 * @param string $url The URL that the request originated from (like $_SERVER['REQUEST_URI'] but already sanitized)
	 * @param bool $triggerReady Whether or not the ready() hook should be triggered (default=false)
	 * @param string $reason Reason why 404 occurred, for debugging purposes (en text)
	 * @param WireException|Wire404Exception $exception Exception that was thrown or that indicates details of error
	 * @throws WireException
	 * @return string
	 */
	protected function ___pageNotFound($page, $url, $triggerReady = false, $reason = '', $exception = null) {
		
		if(!$exception) {
			// create exception but do not throw
			$exception = new Wire404Exception($reason, Wire404Exception::codeNonexist); 
		}

		$this->failed($exception, $reason, $page, $url); 
		$this->responseType = self::responseTypeError; 
		$this->header404();

		$page = $this->http404Page();
		if($page->id) {
			$this->wire('page', $page); 
			if($triggerReady) $this->ready();
			return $page->render();
		} else {
			return "404 page not found";
		}
	}

	/**
	 * Handler for path hooks
	 * 
	 * No need to hook this method directly, instead use a path hook. 
	 * 
	 * #pw-internal
	 * 
	 * @param string $path
	 * @param bool|string|array|Page Output so far, or false if none
	 * @return bool|string|array 
	 *   Return false if path cannot be handled
	 *   Return true if path handled silently
	 *   Return string for output to send
	 *   Return array for JSON output to send
	 *   Return Page object to make it the page that is rendered
	 * 
	 */
	protected function ___pathHooks($path, $out) {
		if($path && $out) {} // ignore
		return $this->pathHooksReturnValue;
	}

	/**
	 * @return NullPage|Page
	 * 
	 */
	protected function http404Page() {
		if($this->http404Page) return $this->http404Page;
		$config = $this->config;
		$pages = $this->wire()->pages;
		$this->http404Page = $config->http404PageID ? $pages->get($config->http404PageID) : $pages->newNullPage(); 
		return $this->http404Page;
	}
	
	/**
	 * Send a 404 header, but not more than once per request
	 * 
	 */
	protected function header404() {
		static $n = 0;
		if($n) return;
		$http = new WireHttp();
		$this->wire($http);
		$http->sendStatusHeader(404);
		$n++;
	}

	/**
	 * Perform redirect
	 * 
	 * @param string $url
	 * @param bool $permanent
	 * 
	 */
	protected function redirect($url, $permanent = true) {
		$session = $this->wire()->session;
		$this->setResponseType(self::responseTypeRedirect);
		if($permanent) {
			$session->redirect($url);
		} else {
			$session->location($url);
		}
	}

	/**
	 * Return the response type for this request, as one of the responseType constants
	 *
	 * @return int
	 *
	 */
	public function getResponseType() {
		return $this->responseType; 
	}

	/**
	 * Set the response type for this request, see responseType constants in this class
	 *
	 * @param int $responseType
	 *
	 */
	public function setResponseType($responseType) {
		$this->responseType = (int) $responseType; 
	}

	/**
	 * Set whether any redirects should be performed after the API ready() call
	 * 
	 * This is used by LanguageSupportPageNames to delay redirects until after http/https schema is determined. 
	 *
	 * @param bool $delayRedirects
	 *
	 */
	public function setDelayRedirects($delayRedirects) {
		$this->delayRedirects = $delayRedirects ? true : false;
	}
	
	/**
	 * Are secure pagefiles possible on this system and url?
	 *
	 * @param string $url
	 * @return bool
	 * @since 3.0.166
	 *
	 */
	protected function pagefileSecurePossible($url) {
		$config = $this->wire()->config;

		// if URL does not start from root, prepend root
		if(strpos($url, $config->urls->root) !== 0) $url = $config->urls->root . ltrim($url, '/');

		// if URL is not pointing to the files structure, then this is not a files URL
		if(strpos($url, $config->urls->files) !== 0) return false;

		// pagefileSecure option is enabled and URL pointing to files
		if($config->pagefileSecure) return true;
	
		// check if any templates allow pagefileSecure option
		$allow = false;
		foreach($this->wire()->templates as $template) {
			if(!$template->pagefileSecure) continue;
			$allow = true;
			break;
		}
	
		// if at least one template supports pagefileSecure option we will return true here
		return $allow;
	}
	
	/**
	 * Given a request path (that does not exist) return the closest parent that does exist
	 *
	 * CURRENTLY NOT USED (future use)
	 *
	 * @param string $requestPath Request path
	 * @param string $parentPath Optional minimum required parent path
	 * @return null|Page Returns found parent on success or null if none found
	 * @since 3.0.168
	 *
	 */
	private function getClosestParentPage($requestPath, $parentPath = '') {

		$requestPath = trim($requestPath, '/');
		$parentPath = trim($parentPath, '/');

		// if request path is not in the required start path then exit early
		if($parentPath !== '') {
			if(stripos("/$requestPath/", "/$parentPath/") !== 0) return null;
		}

		$sanitizer = $this->wire()->sanitizer;
		$parent = null;
		$path = '';

		// attempt to match page from beginning of path to find closest parent
		$segments = explode('/', $requestPath);

		foreach($segments as $segment) {
			$seg = $sanitizer->pageName($segment);
			if($seg !== $segment) break;
			$path .= "/$seg";
			if($parentPath !== '' && $path === "/$parentPath") continue;
			$page = $this->pagesGet($path);
			if(!$page->id) break;
			$parent = $page;
		}

		if($parentPath !== '' && !$parent) $parent = $this->pagesGet("/$parentPath");

		return $parent && $parent->id ? $parent : null;
	}

	/**
	 * Get page num URL prefixes
	 *
	 * @return array
	 *
	 */
	protected function pageNumUrlPrefixes() {
		
		$config = $this->wire()->config;
		$pageNumUrlPrefixes = $config->pageNumUrlPrefixes;
		$returnValue = array();
		
		if(!is_array($pageNumUrlPrefixes)) $pageNumUrlPrefixes = array();
		
		if(count($pageNumUrlPrefixes)) {
			foreach($pageNumUrlPrefixes as $prefix) {
				$returnValue[$prefix] = $prefix;
			}
		} else {
			$prefix = $config->pageNumUrlPrefix;
			if(strlen($prefix)) $returnValue[$prefix] = $prefix;
		}
		
		return $returnValue;
	}

}