a:8:{s:4:"name";s:19:"sgb_error_documents";s:6:"author";s:3:"sgb";s:10:"author_uri";s:23:"http://mighthitgold.net";s:7:"version";s:7:"0.1.2.2";s:11:"description";s:35:"Adds error document support to TxP.";s:4:"help";s:2126:"

	<h3>sgb_error_documents Features</h3>
	<p>This plugin adds an mechanism for handling error documents. This plugin was designed as a companion to sgb_url_handler, however it can be used by any plugin/hack (see my site for more info.</p>

	<p>The plugin responds to each error code in one of four possible ways; by displaying an article on your site (ID), redirecting to an error page (URL), including an error document (file) or by simply outputting error text (text). The plugin responds to an error in the order specified above (ID, URL, file and text). If the ID is not set or is not found, the plugin will try the URL. If the URL is not set the plugin will try the file. If the file is not found, the plugin will output the text, defaulting to standard message if custom text is not set.</p>

	<p>If an error code is passed to the plugin that is not under stood, the plugin will not do anything.</p>

	<h3>Configuration</h3>
	<p>Right now configuration is handled by the array in sgb_error_documents_config. Each error code has four elements: id, url, file and text.</p>
	<dl>
		<dt>id</dt>
		<dd>The id should be of an article available in your article database. You may wish set up a dedicated "Errors" section to prevent the errors articles from being listed with your normal posts.</dd>
		<dt>url</dt>
		<dd>The URL should be an absolute URL to a page explaining the specified error code. If this error is triggered users will be redirected to this page.</dd>
		<dt>file</dt>
		<dd>The file element should be a relative path (to index.php) to a file explaining a particular error code. The function will exit() immediately following the inclusion of the file (terminating any further TxP actions).</dd>
		<dt>text</dt>
		<dd>This text will be echoed to the browser, if it is not specified a default message will be displayed. This text can contained HTML code. The plugin will issue an exit() call immediately after echoing the text (terminating any further TxP actions).</dd>
	</dl>

	<p>In all instances (except for URL redirections) the plugin will issue the appropriate error header.</p>	
";s:4:"code";s:2715:"
/**
 * This function defines all the aspects of sgb_error_documents. 
 */
function sgb_error_documents_config() // array
{
	// 301 Moved Permanently
	// Do not change the 301 unless you know what you're doing!
	$r['error_documents']['301']['id']   = null;
	$r['error_documents']['301']['url']  = 1;
	$r['error_documents']['301']['file'] = null;
	$r['error_documents']['301']['text'] = null;

	// 403 Forbidden
	$r['error_documents']['403']['id']   = null;
	$r['error_documents']['403']['url']  = null;
	$r['error_documents']['403']['file'] = null;
	$r['error_documents']['403']['text'] = null;

	// 404 File Not Found
	$r['error_documents']['404']['id']   = null;
	$r['error_documents']['404']['url']  = null;
	$r['error_documents']['404']['file'] = null;
	$r['error_documents']['404']['text'] = null;

	return $r;
}

// Don't edit below this line --

function sgb_error_document($code = '', $extra = null) // void
{
	$sgb_config = sgb_error_documents_config();

	$headers = array (
		'301' => 'HTTP/1.1 301 Moved Permanently', 
		'403' => 'HTTP/1.0 403 Forbidden', 
		'404' => 'HTTP/1.0 404 Not Found', 
	);

	$default_text = array (
		'301' => '<h1>301 Moved Permanently</h1>', 
		'403' => '<h1>403 Forbidden</h1>', 
		'404' => '<h1>404 Not Found</h1>',
	);

	if (@isset($headers[$code])) {
		// Try the article ID
		if (isset($sgb_config['error_documents'][$code]['id'])) {
			$rs = lookupByID($sgb_config['error_documents'][$code]['id']);

			if (!empty($rs['ID'])) {
				// Set the ID so TxP can render it, if setting it is out, redirect
				if (function_exists('sgb_url_handler_set')) {
					header($headers[$code]);
					sgb_url_handler_set('id', $sgb_config['error_documents'][$code]['id']);
					return;
				} else {
					header('Location: '.hu.'?id='.$sgb_config['error_documents'][$code]['id']);
					exit();
				}
			}
		}
		
		// Try redirecting to the error page
		if (isset($sgb_config['error_documents'][$code]['url'])) {
			$url = (isset($extra)) ? $extra : $sgb_config['error_documents'][$code]['url'];
			header($headers[$code]);
			header('Location: '.$url);
			header("Connection: close");
			exit();
		}

		// Try including the error file
		if (isset($sgb_config['error_documents'][$code]['file']) && @is_file($sgb_config['error_documents'][$code]['file'])) {
			header($headers[$code]);
			@include_once($sgb_config['error_documents'][$code]['file']);
			exit();
		}
		
		// Output the error text
		$text = (isset($sgb_config['error_documents'][$code]['text'])) ? $sgb_config['error_documents'][$code]['text'] : $default_text[$code];

		header($headers[$code]);
		exit($text);
	} else {
		return;
	}
}
";s:3:"md5";s:32:"24be5623da7d264b8aa830653b10219a";}