feedwordpress / feedwordpress.php

feedwordpress.php in FeedWordPress 2012.1212, at feedwordpress.php

2,127 lines 70.7 KB

Raw Download Zip

1	<?php
2	/*
3	Plugin Name: FeedWordPress
4	Plugin URI: http://feedwordpress.radgeek.com/
5	Description: simple and flexible Atom/RSS syndication for WordPress
6	Version: 2012.1212
7	Author: Charles Johnson
8	Author URI: http://radgeek.com/
9	License: GPL
10	*/
11
12	/**
13	* @package FeedWordPress
14	* @version 2012.1212
15	*/
16
17	# This uses code derived from:
18	# - wp-rss-aggregate.php by Kellan Elliot-McCrea <kellan@protest.net>
19	# - MagpieRSS by Kellan Elliot-McCrea <kellan@protest.net>
20	# - Ultra-Liberal Feed Finder by Mark Pilgrim <mark@diveintomark.org>
21	# - WordPress Blog Tool and Publishing Platform <http://wordpress.org/>
22	# according to the terms of the GNU General Public License.
23	#
24	# INSTALLATION: see readme.txt or <http://projects.radgeek.com/install>
25	#
26	# USAGE: once FeedWordPress is installed, you manage just about everything from
27	# the WordPress Dashboard, under the Syndication menu. To ensure that fresh
28	# content is added as it becomes available, you can convince your contributors
29	# to put your XML-RPC URI (if WordPress is installed at
30	# <http://www.zyx.com/blog>, XML-RPC requests should be sent to
31	# <http://www.zyx.com/blog/xmlrpc.php>), or update manually under the
32	# Syndication menu, or set up automatic updates under Syndication --> Settings,
33	# or use a cron job.
34
35	# -- Don't change these unless you know what you're doing...
36
37	define ('FEEDWORDPRESS_VERSION', '2012.1212');
38	define ('FEEDWORDPRESS_AUTHOR_CONTACT', 'http://radgeek.com/contact');
39
40	if (!defined('FEEDWORDPRESS_BLEG')) :
41	define ('FEEDWORDPRESS_BLEG', true);
42	endif;
43
44	// Defaults
45	define ('DEFAULT_SYNDICATION_CATEGORY', 'Contributors');
46	define ('DEFAULT_UPDATE_PERIOD', 60); // value in minutes
47
48	if (isset($_REQUEST['feedwordpress_debug'])) :
49	$feedwordpress_debug = $_REQUEST['feedwordpress_debug'];
50	else :
51	$feedwordpress_debug = get_option('feedwordpress_debug');
52	if (is_string($feedwordpress_debug)) :
53	$feedwordpress_debug = ($feedwordpress_debug == 'yes');
54	endif;
55	endif;
56	define ('FEEDWORDPRESS_DEBUG', $feedwordpress_debug);
57	$feedwordpress_compatibility = true;
58	define ('FEEDWORDPRESS_COMPATIBILITY', $feedwordpress_compatibility);
59
60	define ('FEEDWORDPRESS_CAT_SEPARATOR_PATTERN', '/[:\n]/');
61	define ('FEEDWORDPRESS_CAT_SEPARATOR', "\n");
62
63	define ('FEEDVALIDATOR_URI', 'http://feedvalidator.org/check.cgi');
64
65	define ('FEEDWORDPRESS_FRESHNESS_INTERVAL', 10*60); // Every ten minutes
66
67	define ('FWP_SCHEMA_HAS_USERMETA', 2966);
68	define ('FWP_SCHEMA_USES_ARGS_TAXONOMY', 12694); // Revision # for using $args['taxonomy'] to get link categories
69	define ('FWP_SCHEMA_20', 3308); // Database schema # for WP 2.0
70	define ('FWP_SCHEMA_21', 4772); // Database schema # for WP 2.1
71	define ('FWP_SCHEMA_23', 5495); // Database schema # for WP 2.3
72	define ('FWP_SCHEMA_25', 7558); // Database schema # for WP 2.5
73	define ('FWP_SCHEMA_26', 8201); // Database schema # for WP 2.6
74	define ('FWP_SCHEMA_27', 9872); // Database schema # for WP 2.7
75	define ('FWP_SCHEMA_28', 11548); // Database schema # for WP 2.8
76	define ('FWP_SCHEMA_29', 12329); // Database schema # for WP 2.9
77	define ('FWP_SCHEMA_30', 12694); // Database schema # for WP 3.0
78
79	if (FEEDWORDPRESS_DEBUG) :
80	// Help us to pick out errors, if any.
81	ini_set('error_reporting', E_ALL & ~E_NOTICE);
82	ini_set('display_errors', true);
83
84	// When testing we don't want cache issues to interfere. But this is
85	// a VERY BAD SETTING for a production server. Webmasters will eat your
86	// face for breakfast if you use it, and the baby Jesus will cry. So
87	// make sure FEEDWORDPRESS_DEBUG is FALSE for any site that will be
88	// used for more than testing purposes!
89	define('FEEDWORDPRESS_CACHE_AGE', 1);
90	define('FEEDWORDPRESS_CACHE_LIFETIME', 1);
91	define('FEEDWORDPRESS_FETCH_TIMEOUT_DEFAULT', 60);
92	else :
93	// Hold onto data all day for conditional GET purposes,
94	// but consider it stale after 1 min (requiring a conditional GET)
95	define('FEEDWORDPRESS_CACHE_LIFETIME', 246060);
96	define('FEEDWORDPRESS_CACHE_AGE', 1*60);
97	define('FEEDWORDPRESS_FETCH_TIMEOUT_DEFAULT', 20);
98	endif;
99
100	// Use our the cache settings that we want.
101	add_filter('wp_feed_cache_transient_lifetime', array('FeedWordPress', 'cache_lifetime'));
102
103	// Ensure that we have SimplePie loaded up and ready to go.
104	// We no longer need a MagpieRSS upgrade module. Hallelujah!
105	if (!class_exists('SimplePie')) :
106	require_once(ABSPATH . WPINC . '/class-simplepie.php');
107	endif;
108	require_once(ABSPATH . WPINC . '/class-feed.php');
109
110	if (!function_exists('wp_insert_user')) :
111	require_once (ABSPATH . WPINC . '/registration.php'); // for wp_insert_user
112	endif;
113
114	$dir = dirname(__FILE__);
115	require_once("${dir}/admin-ui.php");
116	require_once("${dir}/feedwordpresssyndicationpage.class.php");
117	require_once("${dir}/compatability.php"); // Legacy API
118	require_once("${dir}/syndicatedpost.class.php");
119	require_once("${dir}/syndicatedlink.class.php");
120	require_once("${dir}/feedwordpresshtml.class.php");
121	require_once("${dir}/feedwordpress-content-type-sniffer.class.php");
122	require_once("${dir}/inspectpostmeta.class.php");
123	require_once("${dir}/syndicationdataqueries.class.php");
124	require_once("${dir}/feedwordpie.class.php");
125	require_once("${dir}/feedwordpie_item.class.php");
126	require_once("${dir}/feedwordpress_file.class.php");
127	require_once("${dir}/feedwordpress_parser.class.php");
128	require_once("${dir}/feedwordpressrpc.class.php");
129	require_once("${dir}/feedwordpresshttpauthenticator.class.php");
130
131	// Magic quotes are just about the stupidest thing ever.
132	if (is_array($_POST)) :
133	$fwp_post = $_POST;
134	if (get_magic_quotes_gpc()) :
135	$fwp_post = stripslashes_deep($fwp_post);
136	endif;
137	endif;
138
139	// Get the path relative to the plugins directory in which FWP is stored
140	preg_match (
141	'\|'.preg_quote(WP_PLUGIN_DIR).'/(.+)$\|',
142	dirname(__FILE__),
143	$ref
144	);
145
146	if (isset($ref[1])) :
147	$fwp_path = $ref[1];
148	else : // Something went wrong. Let's just guess.
149	$fwp_path = 'feedwordpress';
150	endif;
151
152	if (!FeedWordPress::needs_upgrade()) : // only work if the conditions are safe!
153
154	# Syndicated items are generally received in output-ready (X)HTML and
155	# should not be folded, crumpled, mutilated, or spindled by WordPress
156	# formatting filters. But we don't want to interfere with filters for
157	# any locally-authored posts, either.
158	#
159	# What WordPress should really have is a way for upstream filters to
160	# stop downstream filters from running at all. Since it doesn't, and
161	# since a downstream filter can't access the original copy of the text
162	# that is being filtered, what we will do here is (1) save a copy of the
163	# original text upstream, before any other filters run, and then (2)
164	# retrieve that copy downstream, after all the other filters run, if
165	# this is a syndicated post
166
167	add_filter('the_content', 'feedwordpress_preserve_syndicated_content', -10000);
168	add_filter('the_content', 'feedwordpress_restore_syndicated_content', 10000);
169
170	add_action('atom_entry', 'feedwordpress_item_feed_data');
171
172	# Filter in original permalinks if the user wants that
173	add_filter('post_link', 'syndication_permalink', /priority=/ 1, /arguments=/ 3);
174
175	# When foreign URLs are used for permalinks in feeds or display
176	# contexts, they need to be escaped properly.
177	add_filter('the_permalink', 'syndication_permalink_escaped');
178	add_filter('the_permalink_rss', 'syndication_permalink_escaped');
179
180	add_filter('post_comments_feed_link', 'syndication_comments_feed_link');
181
182	# WTF? By default, wp_insert_link runs incoming link_url and link_rss
183	# URIs through default filters that include `wp_kses()`. But `wp_kses()`
184	# just happens to escape any occurrence of & to & -- which just
185	# happens to fuck up any URI with a & to separate GET parameters.
186	remove_filter('pre_link_rss', 'wp_filter_kses');
187	remove_filter('pre_link_url', 'wp_filter_kses');
188
189	# Admin menu
190	add_action('admin_init', array('feedwordpress', 'admin_init'));
191	add_action('admin_menu', 'fwp_add_pages');
192	add_action('admin_notices', 'fwp_check_debug');
193
194	add_action('admin_menu', 'feedwordpress_add_post_edit_controls');
195	add_action('save_post', 'feedwordpress_save_post_edit_controls');
196
197	add_action('admin_footer', array('FeedWordPress', 'admin_footer'));
198
199	# Inbound XML-RPC update methods
200	$feedwordpressRPC = new FeedWordPressRPC;
201
202	# Outbound XML-RPC ping reform
203	remove_action('publish_post', 'generic_ping'); // WP 1.5.x
204	remove_action('do_pings', 'do_all_pings', 10, 1); // WP 2.1, 2.2
205	remove_action('publish_post', '_publish_post_hook', 5, 1); // WP 2.3
206
207	add_action('publish_post', 'fwp_publish_post_hook', 5, 1);
208	add_action('do_pings', 'fwp_do_pings', 10, 1);
209	add_action('feedwordpress_update', 'fwp_hold_pings');
210	add_action('feedwordpress_update_complete', 'fwp_release_pings');
211
212	add_action('syndicated_feed_error', array('FeedWordPressDiagnostic', 'feed_error'), 100, 3);
213
214	add_action('wp_footer', 'debug_out_feedwordpress_footer', -100);
215	add_action('admin_footer', 'debug_out_feedwordpress_footer', -100);
216
217	$feedwordpress = new FeedWordPress;
218
219	# Cron-less auto-update. Hooray!
220	$autoUpdateHook = $feedwordpress->automatic_update_hook();
221	if (!is_null($autoUpdateHook)) :
222	add_action($autoUpdateHook, array($feedwordpress, 'auto_update'));
223	endif;
224
225	add_action('init', array($feedwordpress, 'init'));
226	add_action('shutdown', array($feedwordpress, 'email_diagnostic_log'));
227	add_action('wp_dashboard_setup', array($feedwordpress, 'dashboard_setup'));
228
229	# Default sanitizers
230	add_filter('syndicated_item_content', array('SyndicatedPost', 'resolve_relative_uris'), 0, 2);
231	add_filter('syndicated_item_content', array('SyndicatedPost', 'sanitize_content'), 0, 2);
232
233	else :
234	# Hook in the menus, which will just point to the upgrade interface
235	add_action('admin_menu', 'fwp_add_pages');
236	endif; // if (!FeedWordPress::needs_upgrade())
237
238	################################################################################
239	## LOGGING FUNCTIONS: log status updates to error_log if you want it ###########
240	################################################################################
241
242	class FeedWordPressDiagnostic {
243	function feed_error ($error, $old, $link) {
244	$wpError = $error['object'];
245	$url = $link->uri();
246
247	$mesgs = $wpError->get_error_messages();
248	foreach ($mesgs as $mesg) :
249	$mesg = esc_html($mesg);
250	FeedWordPress::diagnostic(
251	'updated_feeds:errors',
252	"Feed Error: [${url}] update returned error: $mesg"
253	);
254
255	$hours = get_option('feedwordpress_diagnostics_persistent_errors_hours', 2);
256	$span = ($error['ts'] - $error['since']);
257
258	if ($span >= ($hours * 60 * 60)) :
259	$since = date('r', $error['since']);
260	$mostRecent = date('r', $error['ts']);
261	FeedWordPress::diagnostic(
262	'updated_feeds:errors:persistent',
263	"Feed Update Error: [${url}] returning errors"
264	." since ${since}:<br/><code>$mesg</code>",
265	$url, $error['since'], $error['ts']
266	);
267	endif;
268	endforeach;
269	}
270
271	function admin_emails ($id = '') {
272	$users = get_users_of_blog($id);
273	$recipients = array();
274	foreach ($users as $user) :
275	$user_id = (isset($user->user_id) ? $user->user_id : $user->ID);
276	$dude = new WP_User($user_id);
277	if ($dude->has_cap('administrator')) :
278	if ($dude->user_email) :
279	$recipients[] = $dude->user_email;
280	endif;
281	endif;
282	endforeach;
283	return $recipients;
284	}
285	} /* class FeedWordPressDiagnostic */
286
287	function debug_out_human_readable_bytes ($quantity) {
288	$quantity = (int) $quantity;
289	$magnitude = 'B';
290	$orders = array('KB', 'MB', 'GB', 'TB');
291	while (($quantity > (1024*100)) and (count($orders) > 0)) :
292	$quantity = floor($quantity / 1024);
293	$magnitude = array_shift($orders);
294	endwhile;
295	return "${quantity} ${magnitude}";
296	}
297
298	function debug_out_feedwordpress_footer () {
299	if (FeedWordPress::diagnostic_on('memory_usage')) :
300	if (function_exists('memory_get_usage')) :
301	FeedWordPress::diagnostic ('memory_usage', "Memory: Current usage: ".debug_out_human_readable_bytes(memory_get_usage()));
302	endif;
303	if (function_exists('memory_get_peak_usage')) :
304	FeedWordPress::diagnostic ('memory_usage', "Memory: Peak usage: ".debug_out_human_readable_bytes(memory_get_peak_usage()));
305	endif;
306	endif;
307	} /* debug_out_feedwordpress_footer() */
308
309	################################################################################
310	## TEMPLATE API: functions to make your templates syndication-aware ############
311	################################################################################
312
313	/**
314	* is_syndicated: Tests whether the current post in a Loop context, or a post
315	* given by ID number, was syndicated by FeedWordPress. Useful for templates
316	* to determine whether or not to retrieve syndication-related meta-data in
317	* displaying a post.
318	*
319	* @param int $id The post to check for syndicated status. Defaults to the current post in a Loop context.
320	* @return bool TRUE if the post's meta-data indicates it was syndicated; FALSE otherwise
321	*/
322	function is_syndicated ($id = NULL) {
323	return (strlen(get_syndication_feed_id($id)) > 0);
324	} /* function is_syndicated() */
325
326	function feedwordpress_display_url ($url, $before = 60, $after = 0) {
327	$bits = parse_url($url);
328
329	// Strip out crufty subdomains
330	if (isset($bits['host'])) :
331	$bits['host'] = preg_replace('/^www[0-9]*\./i', '', $bits['host']);
332	endif;
333
334	// Reassemble bit-by-bit with minimum of crufty elements
335	$url = (isset($bits['user'])?$bits['user'].'@':'')
336	.(isset($bits['host'])?$bits['host']:'')
337	.(isset($bits['path'])?$bits['path']:'')
338	.(isset($uri_bits['port'])?':'.$uri_bits['port']:'')
339	.(isset($bits['query'])?'?'.$bits['query']:'');
340
341	if (strlen($url) > ($before+$after)) :
342	$url = substr($url, 0, $before).'…'.substr($url, 0 - $after, $after);
343	endif;
344
345	return $url;
346	} /* feedwordpress_display_url () */
347
348	function get_syndication_source_property ($original, $id, $local, $remote = NULL) {
349	$ret = NULL;
350	if (is_null($original)) :
351	$original = FeedWordPress::use_aggregator_source_data();
352	endif;
353
354	if (is_null($remote)) :
355	$remote = $local . '_original';
356	endif;
357
358	$vals = ($original ? get_post_custom_values($remote, $id) : array());
359	if (count($vals) < 1) :
360	$vals = get_post_custom_values($local, $id);
361	endif;
362
363	if (count($vals) > 0) :
364	$ret = $vals[0];
365	endif;
366	return $ret;
367	} /* function get_syndication_source_property () */
368
369	function the_syndication_source_link ($original = NULL, $id = NULL) { echo get_syndication_source_link($original, $id); }
370	function get_syndication_source_link ($original = NULL, $id = NULL) {
371	return get_syndication_source_property($original, $id, 'syndication_source_uri');
372	} /* function get_syndication_source_link() */
373
374	function the_syndication_source ($original = NULL, $id = NULL) { echo get_syndication_source($original, $id); }
375	function get_syndication_source ($original = NULL, $id = NULL) {
376	$ret = get_syndication_source_property($original, $id, 'syndication_source');
377	if (is_null($ret) or strlen(trim($ret)) == 0) : // Fall back to URL of blog
378	$ret = feedwordpress_display_url(get_syndication_source_link());
379	endif;
380	return $ret;
381	} /* function get_syndication_source() */
382
383	function the_syndication_feed ($original = NULL, $id = NULL) { echo get_syndication_feed($original, $id); }
384	function get_syndication_feed ($original = NULL, $id = NULL) {
385	return get_syndication_source_property($original, $id, 'syndication_feed');
386	} /* function get_syndication_feed() */
387
388	function the_syndication_feed_guid ($original = NULL, $id = NULL) { echo get_syndication_feed_guid($original, $id); }
389	function get_syndication_feed_guid ($original = NULL, $id = NULL) {
390	$ret = get_syndication_source_property($original, $id, 'syndication_source_id');
391	if (is_null($ret) or strlen(trim($ret))==0) : // Fall back to URL of feed
392	$ret = get_syndication_feed();
393	endif;
394	return $ret;
395	} /* function get_syndication_feed_guid () */
396
397	function get_syndication_feed_id ($id = NULL) { list($u) = get_post_custom_values('syndication_feed_id', $id); return $u; }
398	function the_syndication_feed_id ($id = NULL) { echo get_syndication_feed_id($id); }
399
400	function get_syndication_feed_object ($id = NULL) {
401	global $feedwordpress;
402
403	$feed_id = get_syndication_feed_id($id);
404	return $feedwordpress->subscription($feed_id);
405	} /* function get_syndication_feed_object() */
406
407	function get_feed_meta ($key, $id = NULL) {
408	$ret = NULL;
409
410	$link = get_syndication_feed_object($id);
411	if (is_object($link) and isset($link->settings[$key])) :
412	$ret = $link->settings[$key];
413	endif;
414	return $ret;
415	} /* function get_feed_meta() */
416
417	function get_syndication_permalink ($id = NULL) {
418	list($u) = get_post_custom_values('syndication_permalink', $id); return $u;
419	}
420	function the_syndication_permalink ($id = NULL) {
421	echo get_syndication_permalink($id);
422	}
423
424	/**
425	* get_local_permalink: returns a string containing the internal permalink
426	* for a post (whether syndicated or not) on your local WordPress installation.
427	* This may be useful if you want permalinks to point to the original source of
428	* an article for most purposes, but want to retrieve a URL for the local
429	* representation of the post for one or two limited purposes (for example,
430	* linking to a comments page on your local aggregator site).
431	*
432	* @param $id The numerical ID of the post to get the permalink for. If empty,
433	* defaults to the current post in a Loop context.
434	* @return string The URL of the local permalink for this post.
435	*
436	* @uses get_permalink()
437	* @global $feedwordpress_the_original_permalink
438	*
439	* @since 2010.0217
440	*/
441	function get_local_permalink ($id = NULL) {
442	global $feedwordpress_the_original_permalink;
443
444	// get permalink, and thus activate filter and force global to be filled
445	// with original URL.
446	$url = get_permalink($id);
447	return $feedwordpress_the_original_permalink;
448	} /* get_local_permalink() */
449
450	/**
451	* the_original_permalink: displays the contents of get_original_permalink()
452	*
453	* @param $id The numerical ID of the post to get the permalink for. If empty,
454	* defaults to the current post in a Loop context.
455	*
456	* @uses get_local_permalinks()
457	* @uses apply_filters
458	*
459	* @since 2010.0217
460	*/
461	function the_local_permalink ($id = NULL) {
462	print apply_filters('the_permalink', get_local_permalink($id));
463	} /* function the_local_permalink() */
464
465	################################################################################
466	## FILTERS: syndication-aware handling of post data for templates and feeds ####
467	################################################################################
468
469	$feedwordpress_the_syndicated_content = NULL;
470	$feedwordpress_the_original_permalink = NULL;
471
472	function feedwordpress_preserve_syndicated_content ($text) {
473	global $feedwordpress_the_syndicated_content;
474
475	$globalExpose = (get_option('feedwordpress_formatting_filters') == 'yes');
476	$localExpose = get_post_custom_values('_feedwordpress_formatting_filters');
477	$expose = ($globalExpose or ((count($localExpose) > 0) and $localExpose[0]));
478
479	if ( is_syndicated() and !$expose ) :
480	$feedwordpress_the_syndicated_content = $text;
481	else :
482	$feedwordpress_the_syndicated_content = NULL;
483	endif;
484	return $text;
485	}
486
487	function feedwordpress_restore_syndicated_content ($text) {
488	global $feedwordpress_the_syndicated_content;
489
490	if ( !is_null($feedwordpress_the_syndicated_content) ) :
491	$text = $feedwordpress_the_syndicated_content;
492	endif;
493
494	return $text;
495	}
496
497	function feedwordpress_item_feed_data () {
498	// In a post context....
499	if (is_syndicated()) :
500	?>
501	<source>
502	<title><?php print htmlspecialchars(get_syndication_source()); ?></title>
503	<link rel="alternate" type="text/html" href="<?php print htmlspecialchars(get_syndication_source_link()); ?>" />
504	<link rel="self" href="<?php print htmlspecialchars(get_syndication_feed()); ?>" />
505	<?php
506	$id = get_syndication_feed_guid();
507	if (strlen($id) > 0) :
508	?>
509	<id><?php print htmlspecialchars($id); ?></id>
510	<?php
511	endif;
512	$updated = get_feed_meta('feed/updated');
513	if (strlen($updated) > 0) : ?>
514	<updated><?php print $updated; ?></updated>
515	<?php
516	endif;
517	?>
518	</source>
519	<?php
520	endif;
521	}
522
523	/**
524	* syndication_permalink: Allow WordPress to use the original remote URL of
525	* syndicated posts as their permalink. Can be turned on or off by by setting in
526	* Syndication => Posts & Links. Saves the old internal permalink in a global
527	* variable for later use.
528	*
529	* @param string $permalink The internal permalink
530	* @return string The new permalink. Same as the old if the post is not
531	* syndicated, or if FWP is set to use internal permalinks, or if the post
532	* was syndicated, but didn't have a proper permalink recorded.
533	*
534	* @uses SyndicatedLink::setting()
535	* @uses get_syndication_permalink()
536	* @uses get_syndication_feed_object()
537	* @uses url_to_postid()
538	* @global $id
539	* @global $feedwordpress_the_original_permalink
540	*/
541	function syndication_permalink ($permalink = '', $post = null, $leavename = false) {
542	global $id;
543	global $feedwordpress_the_original_permalink;
544
545	// Save the local permalink in case we need to retrieve it later.
546	$feedwordpress_the_original_permalink = $permalink;
547
548	if (is_object($post) and isset($post->ID) and !empty($post->ID)) :
549	// Use the post ID we've been provided with.
550	$postId = $post->ID;
551	elseif (is_string($permalink) and strlen($permalink) > 0) :
552	// Map this permalink to a post ID so we can get the correct
553	// permalink even outside of the Post Loop. Props Björn.
554	$postId = url_to_postid($permalink);
555	else :
556	// If the permalink string is empty but Post Loop context
557	// provides an id.
558	$postId = $id;
559	endif;
560
561	$munge = false;
562	$link = get_syndication_feed_object($postId);
563	if (is_object($link)) :
564	$munge = ($link->setting('munge permalink', 'munge_permalink', 'yes') != 'no');
565	endif;
566
567	if ($munge):
568	$uri = get_syndication_permalink($postId);
569	$permalink = ((strlen($uri) > 0) ? $uri : $permalink);
570	endif;
571	return $permalink;
572	} /* function syndication_permalink () */
573
574	/**
575	* syndication_permalink_escaped: Escape XML special characters in syndicated
576	* permalinks when used in feed contexts and HTML display contexts.
577	*
578	* @param string $permalink
579	* @return string
580	*
581	* @uses is_syndicated()
582	* @uses FeedWordPress::munge_permalinks()
583	*
584	*/
585	function syndication_permalink_escaped ($permalink) {
586	/* FIXME: This should review link settings not just global settings */
587	if (is_syndicated() and FeedWordPress::munge_permalinks()) :
588	// This is a foreign link; WordPress can't vouch for its not
589	// having any entities that need to be &-escaped. So we'll do
590	// it here.
591	$permalink = esc_html($permalink);
592	endif;
593	return $permalink;
594	} /* function syndication_permalink_escaped() */
595
596	/**
597	* syndication_comments_feed_link: Escape XML special characters in comments
598	* feed links
599	*
600	* @param string $link
601	* @return string
602	*
603	* @uses is_syndicated()
604	* @uses FeedWordPress::munge_permalinks()
605	*/
606	function syndication_comments_feed_link ($link) {
607	global $feedwordpress_the_original_permalink, $id;
608
609	if (is_syndicated() and FeedWordPress::munge_permalinks()) :
610	// If the source post provided a comment feed URL using
611	// wfw:commentRss or atom:link/@rel="replies" we can make use of
612	// that value here.
613	$source = get_syndication_feed_object();
614	$replacement = NULL;
615	if ($source->setting('munge comments feed links', 'munge_comments_feed_links', 'yes') != 'no') :
616	$commentFeeds = get_post_custom_values('wfw:commentRSS');
617	if (
618	is_array($commentFeeds)
619	and (count($commentFeeds) > 0)
620	and (strlen($commentFeeds[0]) > 0)
621	) :
622	$replacement = $commentFeeds[0];
623
624	// This is a foreign link; WordPress can't vouch for its not
625	// having any entities that need to be &-escaped. So we'll do it
626	// here.
627	$replacement = esc_html($replacement);
628	endif;
629	endif;
630
631	if (is_null($replacement)) :
632	// Q: How can we get the proper feed format, since the
633	// format is, stupidly, not passed to the filter?
634	// A: Kludge kludge kludge kludge!
635	$fancy_permalinks = ('' != get_option('permalink_structure'));
636	if ($fancy_permalinks) :
637	preg_match('\|/feed(/([^/]+))?/?$\|', $link, $ref);
638
639	$format = (isset($ref[2]) ? $ref[2] : '');
640	if (strlen($format) == 0) : $format = get_default_feed(); endif;
641
642	$replacement = trailingslashit($feedwordpress_the_original_permalink) . 'feed';
643	if ($format != get_default_feed()) :
644	$replacement .= '/'.$format;
645	endif;
646	$replacement = user_trailingslashit($replacement, 'single_feed');
647	else :
648	// No fancy permalinks = no problem
649	// WordPress doesn't call get_permalink() to
650	// generate the comment feed URL, so the
651	// comments feed link is never munged by FWP.
652	endif;
653	endif;
654
655	if (!is_null($replacement)) : $link = $replacement; endif;
656	endif;
657	return $link;
658	} /* function syndication_comments_feed_link() */
659
660	################################################################################
661	## ADMIN MENU ADD-ONS: register Dashboard management pages #####################
662	################################################################################
663
664	function fwp_add_pages () {
665	$menu_cap = FeedWordPress::menu_cap();
666	$settings_cap = FeedWordPress::menu_cap(/sub=/ true);
667	$syndicationMenu = FeedWordPress::path('syndication.php');
668
669	add_menu_page(
670	'Syndicated Sites', 'Syndication',
671	$menu_cap,
672	$syndicationMenu,
673	NULL,
674	WP_PLUGIN_URL.'/'.FeedWordPress::path('feedwordpress-tiny.png')
675	);
676
677	do_action('feedwordpress_admin_menu_pre_feeds', $menu_cap, $settings_cap);
678	add_submenu_page(
679	$syndicationMenu, 'Syndicated Sites', 'Syndicated Sites',
680	$settings_cap, $syndicationMenu
681	);
682
683	do_action('feedwordpress_admin_menu_pre_feeds', $menu_cap, $settings_cap);
684	add_submenu_page(
685	$syndicationMenu, 'Syndicated Feeds & Updates', 'Feeds & Updates',
686	$settings_cap, FeedWordPress::path('feeds-page.php')
687	);
688
689	do_action('feedwordpress_admin_menu_pre_posts', $menu_cap, $settings_cap);
690	add_submenu_page(
691	$syndicationMenu, 'Syndicated Posts & Links', 'Posts & Links',
692	$settings_cap, FeedWordPress::path('posts-page.php')
693	);
694
695	do_action('feedwordpress_admin_menu_pre_authors', $menu_cap, $settings_cap);
696	add_submenu_page(
697	$syndicationMenu, 'Syndicated Authors', 'Authors',
698	$settings_cap, FeedWordPress::path('authors-page.php')
699	);
700
701	do_action('feedwordpress_admin_menu_pre_categories', $menu_cap, $settings_cap);
702	add_submenu_page(
703	$syndicationMenu, 'Categories & Tags', 'Categories & Tags',
704	$settings_cap, FeedWordPress::path('categories-page.php')
705	);
706
707	do_action('feedwordpress_admin_menu_pre_performance', $menu_cap, $settings_cap);
708	add_submenu_page(
709	$syndicationMenu, 'FeedWordPress Performance', 'Performance',
710	$settings_cap, FeedWordPress::path('performance-page.php')
711	);
712
713	do_action('feedwordpress_admin_menu_pre_diagnostics', $menu_cap, $settings_cap);
714	add_submenu_page(
715	$syndicationMenu, 'FeedWordPress Diagnostics', 'Diagnostics',
716	$settings_cap, FeedWordPress::path('diagnostics-page.php')
717	);
718	} /* function fwp_add_pages () */
719
720	function fwp_check_debug () {
721	// This is a horrible fucking kludge that I have to do because the
722	// admin notice code is triggered before the code that updates the
723	// setting.
724	if (isset($_POST['feedwordpress_debug'])) :
725	$feedwordpress_debug = $_POST['feedwordpress_debug'];
726	else :
727	$feedwordpress_debug = get_option('feedwordpress_debug');
728	endif;
729	if ($feedwordpress_debug==='yes') :
730	?>
731	<div class="error">
732	<p><strong>FeedWordPress warning.</strong> Debugging mode is <strong>ON</strong>.
733	While it remains on, FeedWordPress displays many diagnostic error messages,
734	warnings, and notices that are ordinarily suppressed, and also turns off all
735	caching of feeds. Use with caution: this setting is absolutely inappropriate
736	for a production server.</p>
737	</div>
738	<?php
739	endif;
740	} /* function fwp_check_debug () */
741
742	################################################################################
743	## fwp_hold_pings() and fwp_release_pings(): Outbound XML-RPC ping reform ####
744	## ... 'coz it's rude to send 500 pings the first time your aggregator runs ####
745	################################################################################
746
747	$fwp_held_ping = NULL; // NULL: not holding pings yet
748
749	function fwp_hold_pings () {
750	global $fwp_held_ping;
751	if (is_null($fwp_held_ping)):
752	$fwp_held_ping = 0; // 0: ready to hold pings; none yet received
753	endif;
754	}
755
756	function fwp_release_pings () {
757	global $fwp_held_ping;
758	if ($fwp_held_ping):
759	if (function_exists('wp_schedule_single_event')) :
760	wp_schedule_single_event(time(), 'do_pings');
761	else :
762	generic_ping($fwp_held_ping);
763	endif;
764	endif;
765	$fwp_held_ping = NULL; // NULL: not holding pings anymore
766	}
767
768	function fwp_do_pings () {
769	if (!is_null($fwp_held_ping) and $post_id) : // Defer until we're done updating
770	$fwp_held_ping = $post_id;
771	elseif (function_exists('do_all_pings')) :
772	do_all_pings();
773	else :
774	generic_ping($fwp_held_ping);
775	endif;
776	}
777
778	function fwp_publish_post_hook ($post_id) {
779	global $fwp_held_ping;
780
781	if (!is_null($fwp_held_ping)) : // Syndicated post. Don't mark with _pingme
782	if ( defined('XMLRPC_REQUEST') )
783	do_action('xmlrpc_publish_post', $post_id);
784	if ( defined('APP_REQUEST') )
785	do_action('app_publish_post', $post_id);
786
787	if ( defined('WP_IMPORTING') )
788	return;
789
790	// Defer sending out pings until we finish updating
791	$fwp_held_ping = $post_id;
792	else :
793	if (function_exists('_publish_post_hook')) : // WordPress 2.3
794	_publish_post_hook($post_id);
795	endif;
796	endif;
797	}
798
799	function feedwordpress_add_post_edit_controls () {
800	global $feedwordpress;
801
802	// Put in Manual Editing checkbox
803	add_meta_box('feedwordpress-post-controls', __('Syndication'), 'feedwordpress_post_edit_controls', 'post', 'side', 'high');
804
805	add_filter('user_can_richedit', array($feedwordpress, 'user_can_richedit'), 1000, 1);
806
807	if (FeedWordPress::diagnostic_on('syndicated_posts:static_meta_data')) :
808	$GLOBALS['inspectPostMeta'] = new InspectPostMeta;
809	endif;
810	} // function FeedWordPress::postEditControls
811
812	function feedwordpress_post_edit_controls () {
813	global $post;
814
815	$frozen_values = get_post_custom_values('_syndication_freeze_updates', $post->ID);
816	$frozen_post = (count($frozen_values) > 0 and 'yes' == $frozen_values[0]);
817
818	if (is_syndicated($post->ID)) :
819	?>
820	<p>This is a syndicated post, which originally appeared at
821	<cite><?php print esc_html(get_syndication_source(NULL, $post->ID)); ?></cite>.
822	<a href="<?php print esc_html(get_syndication_permalink($post->ID)); ?>">View original post</a>.</p>
823
824	<p><input type="hidden" name="feedwordpress_noncename" id="feedwordpress_noncename" value="<?php print wp_create_nonce(plugin_basename(__FILE__)); ?>" />
825	<label><input type="checkbox" name="freeze_updates" value="yes" <?php if ($frozen_post) : ?>checked="checked"<?php endif; ?> /> <strong>Manual editing.</strong>
826	If set, FeedWordPress will not overwrite the changes you make manually
827	to this post, if the syndicated content is updated on the
828	feed.</label></p>
829	<?php
830	else :
831	?>
832	<p>This post was created locally at this website.</p>
833	<?php
834	endif;
835	} // function feedwordpress_post_edit_controls () */
836
837	function feedwordpress_save_post_edit_controls ( $post_id ) {
838	global $post;
839
840	if (!isset($_POST['feedwordpress_noncename']) or !wp_verify_nonce($_POST['feedwordpress_noncename'], plugin_basename(__FILE__))) :
841	return $post_id;
842	endif;
843
844	// Verify if this is an auto save routine. If it is our form has
845	// not been submitted, so we don't want to do anything.
846	if ( defined('DOING_AUTOSAVE') and DOING_AUTOSAVE ) :
847	return $post_id;
848	endif;
849
850	// Check permissions
851	if ( !current_user_can( 'edit_'.$_POST['post_type'], $post_id) ) :
852	return $post_id;
853	endif;
854
855	// OK, we're golden. Now let's save some data.
856	if (isset($_POST['freeze_updates'])) :
857	update_post_meta($post_id, '_syndication_freeze_updates', $_POST['freeze_updates']);
858	$ret = $_POST['freeze_updates'];
859	else :
860	delete_post_meta($post_id, '_syndication_freeze_updates');
861	$ret = NULL;
862	endif;
863
864	return $ret;
865	} // function feedwordpress_save_edit_controls
866
867	################################################################################
868	## class FeedWordPress #########################################################
869	################################################################################
870
871	// class FeedWordPress: handles feed updates and plugs in to the XML-RPC interface
872	class FeedWordPress {
873	var $strip_attrs = array (
874	array('[a-z]+', 'style'),
875	array('[a-z]+', 'target'),
876	);
877	var $uri_attrs = array (
878	array('a', 'href'),
879	array('applet', 'codebase'),
880	array('area', 'href'),
881	array('blockquote', 'cite'),
882	array('body', 'background'),
883	array('del', 'cite'),
884	array('form', 'action'),
885	array('frame', 'longdesc'),
886	array('frame', 'src'),
887	array('iframe', 'longdesc'),
888	array('iframe', 'src'),
889	array('head', 'profile'),
890	array('img', 'longdesc'),
891	array('img', 'src'),
892	array('img', 'usemap'),
893	array('input', 'src'),
894	array('input', 'usemap'),
895	array('ins', 'cite'),
896	array('link', 'href'),
897	array('object', 'classid'),
898	array('object', 'codebase'),
899	array('object', 'data'),
900	array('object', 'usemap'),
901	array('q', 'cite'),
902	array('script', 'src')
903	);
904
905	var $feeds = NULL;
906	var $feedurls = NULL;
907	var $httpauth = NULL;
908
909	# function FeedWordPress (): Contructor; retrieve a list of feeds
910	function FeedWordPress () {
911	$this->feeds = array ();
912	$this->feedurls = array();
913	$links = FeedWordPress::syndicated_links();
914	if ($links): foreach ($links as $link):
915	$id = intval($link->link_id);
916	$url = $link->link_rss;
917
918	// Store for later reference.
919	$this->feeds[$id] = $id;
920	if (strlen($url) > 0) :
921	$this->feedurls[$url] = $id;
922	endif;
923	endforeach; endif;
924
925	$this->httpauth = new FeedWordPressHTTPAuthenticator;
926	} // FeedWordPress::FeedWordPress ()
927
928	function subscribed ($id) {
929	return (isset($this->feedurls[$id]) or isset($this->feeds[$id]));
930	} /* FeedWordPress::subscribed () */
931
932	function subscription ($which) {
933	$sub = NULL;
934
935	if (is_string($which) and isset($this->feedurls[$which])) :
936	$which = $this->feedurls[$which];
937	endif;
938
939	if (isset($this->feeds[$which])) :
940	$sub = $this->feeds[$which];
941	endif;
942
943	// Load 'er up if you haven't already.
944	if (!is_null($sub) and !($sub InstanceOf SyndicatedLink)) :
945	$link = new SyndicatedLink($sub);
946	$this->feeds[$which] = $link;
947	$sub = $link;
948	endif;
949
950	return $sub;
951	} /* FeedWordPress::subscriptions () */
952
953	# function update (): polls for updates on one or more Contributor feeds
954	#
955	# Arguments:
956	# ----------
957	# * $uri (string): either the URI of the feed to poll, the URI of the
958	# (human-readable) website whose feed you want to poll, or NULL.
959	#
960	# If $uri is NULL, then FeedWordPress will poll any feeds that are
961	# ready for polling. It will not poll feeds that are marked as
962	# "Invisible" Links (signifying that the subscription has been
963	# de-activated), or feeds that are not yet stale according to their
964	# TTL setting (which is either set in the feed, or else set
965	# randomly within a window of 30 minutes - 2 hours).
966	#
967	# Returns:
968	# --------
969	# * Normally returns an associative array, with 'new' => the number
970	# of new posts added during the update, and 'updated' => the number
971	# of old posts that were updated during the update. If both numbers
972	# are zero, there was no change since the last poll on that URI.
973	#
974	# * Returns NULL if URI it was passed was not a URI that this
975	# installation of FeedWordPress syndicates.
976	#
977	# Effects:
978	# --------
979	# * One or more feeds are polled for updates
980	#
981	# * If the feed Link does not have a hardcoded name set, its Link
982	# Name is synchronized with the feed's title element
983	#
984	# * If the feed Link does not have a hardcoded URI set, its Link URI
985	# is synchronized with the feed's human-readable link element
986	#
987	# * If the feed Link does not have a hardcoded description set, its
988	# Link Description is synchronized with the feed's description,
989	# tagline, or subtitle element.
990	#
991	# * The time of polling is recorded in the feed's settings, and the
992	# TTL (time until the feed is next available for polling) is set
993	# either from the feed (if it is supplied in the ttl or syndication
994	# module elements) or else from a randomly-generated time window
995	# (between 30 minutes and 2 hours).
996	#
997	# * New posts from the polled feed are added to the WordPress store.
998	#
999	# * Updates to existing posts since the last poll are mirrored in the
1000	# WordPress store.
1001	#
1002	function update ($uri = null, $crash_ts = null) {
1003	global $wpdb;
1004
1005	if (FeedWordPress::needs_upgrade()) : // Will make duplicate posts if we don't hold off
1006	return NULL;
1007	endif;
1008
1009	if (!is_null($uri) and $uri != '*') :
1010	$uri = trim($uri);
1011	else : // Update all
1012	if ($this->update_hooked) :
1013	$diag = $this->update_hooked;
1014	else :
1015	$diag = 'Initiating a MANUAL check-in on the update schedule at '.date('r', time());
1016	endif;
1017	$this->diagnostic('update_schedule:check', $diag);
1018
1019	update_option('feedwordpress_last_update_all', time());
1020	endif;
1021
1022	do_action('feedwordpress_update', $uri);
1023
1024	if (is_null($crash_ts)) :
1025	$crash_ts = $this->crash_ts();
1026	endif;
1027
1028	// Randomize order for load balancing purposes
1029	$feed_set = array_keys($this->feeds);
1030	shuffle($feed_set);
1031
1032	$updateWindow = (int) get_option('feedwordpress_update_window', DEFAULT_UPDATE_PERIOD) * 60 /* sec/min */;
1033	$interval = (int) get_option('feedwordpress_freshness', FEEDWORDPRESS_FRESHNESS_INTERVAL);
1034	$portion = max(
1035	(int) ceil(count($feed_set) / ($updateWindow / $interval)),
1036	10
1037	);
1038
1039	$max_polls = apply_filters('feedwordpress_polls_per_update', get_option(
1040	'feedwordpress_polls_per_update', $portion
1041	), $uri);
1042
1043	$feed_set = apply_filters('feedwordpress_update_feeds', $feed_set, $uri);
1044
1045
1046	// Loop through and check for new posts
1047	$delta = NULL; $remaining = $max_polls;
1048	foreach ($feed_set as $feed_id) :
1049
1050	$feed = $this->subscription($feed_id);
1051
1052	// Has this process overstayed its welcome?
1053	if (
1054	// Over time limit?
1055	(!is_null($crash_ts) and (time() > $crash_ts))
1056
1057	// Over feed count?
1058	or ($remaining == 0)
1059	) :
1060	break;
1061	endif;
1062
1063	$pinged_that = (is_null($uri) or ($uri=='*') or in_array($uri, array($feed->uri(), $feed->homepage())));
1064
1065	if (!is_null($uri)) : // A site-specific ping always updates
1066	$timely = true;
1067	else :
1068	$timely = $feed->stale();
1069	endif;
1070
1071	if ($pinged_that and is_null($delta)) : // If at least one feed was hit for updating...
1072	$delta = array('new' => 0, 'updated' => 0); // ... don't return error condition
1073	endif;
1074
1075	if ($pinged_that and $timely) :
1076	$remaining = $remaining - 1;
1077
1078	do_action('feedwordpress_check_feed', $feed->settings);
1079	$start_ts = time();
1080	$added = $feed->poll($crash_ts);
1081	do_action('feedwordpress_check_feed_complete', $feed->settings, $added, time() - $start_ts);
1082
1083	if (is_array($added)) : // Success
1084	if (isset($added['new'])) : $delta['new'] += $added['new']; endif;
1085	if (isset($added['updated'])) : $delta['updated'] += $added['updated']; endif;
1086	endif;
1087	endif;
1088	endforeach;
1089
1090	do_action('feedwordpress_update_complete', $delta);
1091
1092	return $delta;
1093	}
1094
1095	function crash_ts ($default = NULL) {
1096	$crash_dt = (int) get_option('feedwordpress_update_time_limit', 0);
1097	if ($crash_dt > 0) :
1098	$crash_ts = time() + $crash_dt;
1099	else :
1100	$crash_ts = $default;
1101	endif;
1102	return $crash_ts;
1103	}
1104
1105	function secret_key () {
1106	$secret = get_option('feedwordpress_secret_key', false);
1107	if (!$secret) : // Generate random key.
1108	$secret = substr(md5(uniqid(microtime())), 0, 6);
1109	update_option('feedwordpress_secret_key', $secret);
1110	endif;
1111	return $secret;
1112	}
1113
1114	function has_secret () {
1115	return ($this->by_request('feedwordpress_key', $this->secret_key()));
1116	}
1117
1118	// Utility function so I don't have to repeat myself w/ 1,000,003 isset()'s
1119	function by_request ($param, $eq = NULL) {
1120	$match = false;
1121	if (isset($_REQUEST[$param])) :
1122	$match = (is_null($eq) ? $_REQUEST[$param] : ($eq==$_REQUEST[$param]));
1123	endif;
1124	return $match;
1125	}
1126
1127	var $update_hooked = NULL;
1128	function automatic_update_hook ($params = array()) {
1129	$params = wp_parse_args($params, array( // Defaults
1130	'setting only' => false,
1131	));
1132	$hook = get_option('feedwordpress_automatic_updates', NULL);
1133	$method = 'FeedWordPress option';
1134
1135	// Allow for forced behavior in testing.
1136	if (
1137	!$params['setting only']
1138	and $this->has_secret()
1139	and $this->by_request('automatic_update')
1140	) :
1141	$hook = $_REQUEST['automatic_update'];
1142	$method = 'URL parameter';
1143	endif;
1144
1145	$exact = $hook; // Before munging
1146
1147	if (!!$hook) :
1148	if ($hook != 'init') : // Constrain values.
1149	$hook = 'shutdown';
1150	endif;
1151	endif;
1152
1153	if ($hook) :
1154	$this->update_hooked = "Initiating an AUTOMATIC CHECK FOR UPDATES ON PAGE LOAD ".$hook." due to ".$method." = ".trim($this->val($exact));
1155	endif;
1156
1157	return $hook;
1158	}
1159	function last_update_all () {
1160	$last = get_option('feedwordpress_last_update_all');
1161	if ($this->has_secret() and $this->by_request('automatic_update')) :
1162	$last = 1; // A long, long time ago.
1163	elseif ($this->has_secret() and $this->by_request('last_update_all')) :
1164	$last = $_REQUEST['last_update_all'];
1165	endif;
1166	return $last;
1167	}
1168	function force_update_all () {
1169	return ($this->has_secret() and $this->by_request('force_update_feeds'));
1170	}
1171
1172	function stale () {
1173	if (!is_null($this->automatic_update_hook())) :
1174	// Do our best to avoid possible simultaneous
1175	// updates by getting up-to-the-minute settings.
1176
1177	$last = $this->last_update_all();
1178
1179	// If we haven't updated all yet, give it a time window
1180	if (false === $last) :
1181	$ret = false;
1182	update_option('feedwordpress_last_update_all', time());
1183
1184	// Otherwise, check against freshness interval
1185	elseif (is_numeric($last)) : // Expect a timestamp
1186	$freshness = get_option('feedwordpress_freshness');
1187	if (false === $freshness) : // Use default
1188	$freshness = FEEDWORDPRESS_FRESHNESS_INTERVAL;
1189	endif;
1190	$ret = ( (time() - $last) > $freshness );
1191
1192	// This should never happen.
1193	else :
1194	FeedWordPress::critical_bug('FeedWordPress::stale::last', $last, __LINE__, __FILE__);
1195	endif;
1196
1197	else :
1198	$ret = false;
1199	endif;
1200	return $ret;
1201	} // FeedWordPress::stale()
1202
1203	static function admin_init () {
1204	// WordPress 3.5+ compat: the WP devs are in the midst of removing Links from the WordPress core. Eventually we'll have to deal
1205	// with the possible disappearance of the wp_links table as a whole; but in the meantime, we just need to turn on the interface
1206	// element to avoid problems with user capabilities that presume the presence of the Links Manager in the admin UI.
1207	if (!intval(get_option('link_manager_enabled', false))) :
1208	update_option('link_manager_enabled', true);
1209	endif;
1210	} /* FeedWordPress::admin_init() */
1211
1212	function init () {
1213	global $fwp_path;
1214
1215	// If this is a FeedWordPress admin page, queue up scripts for AJAX
1216	// functions that FWP uses. If it is a display page or a non-FWP admin
1217	// page, don't.
1218	wp_register_style('feedwordpress-elements', WP_PLUGIN_URL.'/'.$fwp_path.'/feedwordpress-elements.css');
1219	if (FeedWordPressSettingsUI::is_admin()) :
1220	// For JavaScript that needs to be generated dynamically
1221	add_action('admin_print_scripts', array('FeedWordPressSettingsUI', 'admin_scripts'));
1222
1223	// For CSS that needs to be generated dynamically.
1224	add_action('admin_print_styles', array('FeedWordPressSettingsUI', 'admin_styles'));
1225
1226	wp_enqueue_style('dashboard');
1227	wp_enqueue_style('feedwordpress-elements');
1228
1229	/*if (function_exists('wp_admin_css')) :
1230	wp_admin_css('css/dashboard');
1231	endif;*/
1232	endif;
1233
1234	// This is a special post status for hiding posts that have expired
1235	register_post_status('fwpretired', array(
1236	'label' => _x('Retired', 'post'),
1237	'label_count' => _n_noop('Retired <span class="count">(%s)</span>', 'Retired <span class="count">(%s)</span>'),
1238	'exclude_from_search' => true,
1239	'public' => false,
1240	'publicly_queryable' => false,
1241	'show_in_admin_all_list' => false,
1242	'show_in_admin_status_list' => true,
1243	));
1244	add_action(
1245	/hook=/ 'template_redirect',
1246	/function=/ array($this, 'redirect_retired'),
1247	/priority=/ -100
1248	);
1249
1250	$this->clear_cache_magic_url();
1251	$this->update_magic_url();
1252	} /* FeedWordPress::init() */
1253
1254	function redirect_retired () {
1255	global $wp_query;
1256	if (is_singular()) :
1257	if ('fwpretired'==$wp_query->post->post_status) :
1258	do_action('feedwordpress_redirect_retired', $wp_query->post);
1259
1260	if (!($template = get_404_template())) :
1261	$template = get_index_template();
1262	endif;
1263	if ($template = apply_filters('template_include', $template)) :
1264	header("HTTP/1.1 410 Gone");
1265	include($template);
1266	endif;
1267	exit;
1268	endif;
1269	endif;
1270	}
1271
1272	function dashboard_setup () {
1273	$see_it = FeedWordPress::menu_cap();
1274
1275	if (current_user_can($see_it)) :
1276	// Get the stylesheet
1277	wp_enqueue_style('feedwordpress-elements');
1278
1279	$widget_id = 'feedwordpress_dashboard';
1280	$widget_name = __('Syndicated Sources');
1281	$column = 'side';
1282	$priority = 'core';
1283
1284	// I would love to use wp_add_dashboard_widget() here and save
1285	// myself some trouble. But WP 3 does not yet have any way to
1286	// push a dashboard widget onto the side, or to give it a default
1287	// location.
1288	add_meta_box(
1289	/id=/ $widget_id,
1290	/title=/ $widget_name,
1291	/callback=/ array($this, 'dashboard'),
1292	/page=/ 'dashboard',
1293	/context=/ $column,
1294	/priority=/ $priority
1295	);
1296	/control_callback= array($this, 'dashboard_control') /
1297
1298	// This is kind of rude, I know, but the dashboard widget isn't
1299	// worth much if users don't know that it exists, and I don't
1300	// know of any better way to reorder the boxen.
1301	//
1302	// Gleefully ripped off of codex.wordpress.org/Dashboard_Widgets_API
1303
1304	// Globalize the metaboxes array, this holds all the widgets for wp-admin
1305	global $wp_meta_boxes;
1306
1307	// Get the regular dashboard widgets array
1308	// (which has our new widget already but at the end)
1309
1310	$normal_dashboard = $wp_meta_boxes['dashboard'][$column][$priority];
1311
1312	// Backup and delete our new dashbaord widget from the end of the array
1313	if (isset($normal_dashboard[$widget_id])) :
1314	$backup = array();
1315	$backup[$widget_id] = $normal_dashboard[$widget_id];
1316	unset($normal_dashboard[$widget_id]);
1317
1318	// Merge the two arrays together so our widget is at the
1319	// beginning
1320	$sorted_dashboard = array_merge($backup, $normal_dashboard);
1321
1322	// Save the sorted array back into the original metaboxes
1323	$wp_meta_boxes['dashboard'][$column][$priority] = $sorted_dashboard;
1324	endif;
1325	endif;
1326	} /* FeedWordPress::dashboard_setup () */
1327
1328	function dashboard () {
1329	$syndicationPage = new FeedWordPressSyndicationPage(dirname(__FILE__).'/syndication.php');
1330	$syndicationPage->dashboard_box($syndicationPage);
1331	} /* FeedWordPress::dashboard () */
1332
1333	function user_can_richedit ($rich_edit) {
1334
1335	global $post;
1336
1337	if (is_syndicated($post->ID)) :
1338	// Disable visual editor and only allow operations
1339	// directly on HTML if post is syndicated.
1340	$rich_edit = false;
1341	endif;
1342
1343	return $rich_edit;
1344
1345	} /* FeedWordPress::user_can_richedit () */
1346
1347	function update_magic_url () {
1348	global $wpdb;
1349
1350	// Explicit update request in the HTTP request (e.g. from a cron job)
1351	if ($this->update_requested()) :
1352	$this->update_hooked = "Initiating a CRON JOB CHECK-IN ON UPDATE SCHEDULE due to URL parameter = ".trim($this->val($_REQUEST['update_feedwordpress']));
1353
1354	$this->update($this->update_requested_url());
1355
1356	if (FEEDWORDPRESS_DEBUG and count($wpdb->queries) > 0) :
1357	$mysqlTime = 0.0;
1358	$byTime = array();
1359	foreach ($wpdb->queries as $query) :
1360	$time = $query[1] * 1000000.0;
1361	$mysqlTime += $query[1];
1362	if (!isset($byTime[$time])) : $byTime[$time] = array(); endif;
1363	$byTime[$time][] = $query[0]. ' // STACK: ' . $query[2];
1364	endforeach;
1365	krsort($byTime);
1366
1367	foreach ($byTime as $time => $querySet) :
1368	foreach ($querySet as $query) :
1369	print "[".(sprintf('%4.4f', $time/1000.0)) . "ms] $query\n";
1370	endforeach;
1371	endforeach;
1372	echo $this->log_prefix()."$wpdb->num_queries queries. $mysqlTime seconds in MySQL. Total of "; timer_stop(1); print " seconds.";
1373	endif;
1374
1375	debug_out_feedwordpress_footer();
1376
1377	// Magic URL should return nothing but a 200 OK header packet
1378	// when successful.
1379	exit;
1380	endif;
1381	} /* FeedWordPress::magic_update_url () */
1382
1383	function clear_cache_magic_url () {
1384	if ($this->clear_cache_requested()) :
1385	$this->clear_cache();
1386	endif;
1387	} /* FeedWordPress::clear_cache_magic_url() */
1388
1389	function clear_cache_requested () {
1390	return (
1391	isset($_GET['clear_cache'])
1392	and $_GET['clear_cache']
1393	);
1394	} /* FeedWordPress::clear_cache_requested() */
1395
1396	function update_requested () {
1397	return FeedWordPress::by_request('update_feedwordpress');
1398	} // FeedWordPress::update_requested()
1399
1400	function update_requested_url () {
1401	$ret = null;
1402
1403	if (($_REQUEST['update_feedwordpress']=='*')
1404	or (preg_match('\|^http://.*\|i', $_REQUEST['update_feedwordpress']))) :
1405	$ret = $_REQUEST['update_feedwordpress'];
1406	endif;
1407
1408	return $ret;
1409	} // FeedWordPress::update_requested_url()
1410
1411	function auto_update () {
1412	if ($this->stale()) :
1413	$this->update();
1414	endif;
1415	} /* FeedWordPress::auto_update () */
1416
1417	function find_link ($uri, $field = 'link_rss') {
1418	global $wpdb;
1419
1420	$unslashed = untrailingslashit($uri);
1421	$slashed = trailingslashit($uri);
1422	$link_id = $wpdb->get_var($wpdb->prepare("
1423	SELECT link_id FROM $wpdb->links WHERE $field IN ('%s', '%s')
1424	LIMIT 1", $unslashed, $slashed
1425	));
1426
1427	return $link_id;
1428	} /* FeedWordPress::find_link () */
1429
1430	function syndicate_link ($name, $uri, $rss) {
1431	// Get the category ID#
1432	$cat_id = FeedWordPress::link_category_id();
1433	if (!is_wp_error($cat_id)) :
1434	$link_category = array($cat_id);
1435	else :
1436	$link_category = array();
1437	endif;
1438
1439	// WordPress gets cranky if there's no homepage URI
1440	if (!is_string($uri) or strlen($uri)<1) : $uri = $rss; endif;
1441
1442	// Check if this feed URL is already being syndicated.
1443	$link_id = wp_insert_link(array(
1444	"link_id" => FeedWordPress::find_link($rss), // insert if nothing was found; else update
1445	"link_rss" => $rss,
1446	"link_name" => $name,
1447	"link_url" => $uri,
1448	"link_category" => $link_category,
1449	"link_visible" => 'Y', // reactivate if inactivated
1450	));
1451
1452	return $link_id;
1453	} /* function FeedWordPress::syndicate_link() */
1454
1455	/static/ function syndicated_status ($what, $default) {
1456	$ret = get_option("feedwordpress_syndicated_{$what}_status");
1457	if (!$ret) :
1458	$ret = $default;
1459	endif;
1460	return $ret;
1461	} /* FeedWordPress::syndicated_status() */
1462
1463	function on_unfamiliar ($what = 'author') {
1464	switch ($what) :
1465	case 'category' : $suffix = ':category'; break;
1466	case 'post_tag' : $suffix = ':post_tag'; break;
1467	default: $suffix = '';
1468	endswitch;
1469
1470	return get_option('feedwordpress_unfamiliar_'.$what, 'create'.$suffix);
1471	} // function FeedWordPress::on_unfamiliar()
1472
1473	function null_email_set () {
1474	$base = get_option('feedwordpress_null_email_set');
1475
1476	if ($base===false) :
1477	$ret = array('noreply@blogger.com'); // default
1478	else :
1479	$ret = array_map('strtolower',
1480	array_map('trim', explode("\n", $base)));
1481	endif;
1482	$ret = apply_filters('syndicated_item_author_null_email_set', $ret);
1483	return $ret;
1484
1485	} /* FeedWordPress::null_email_set () */
1486
1487	function is_null_email ($email) {
1488	$ret = in_array(strtolower(trim($email)), FeedWordPress::null_email_set());
1489	$ret = apply_filters('syndicated_item_author_is_null_email', $ret, $email);
1490	return $ret;
1491	} /* FeedWordPress::is_null_email () */
1492
1493	function use_aggregator_source_data () {
1494	$ret = get_option('feedwordpress_use_aggregator_source_data');
1495	return apply_filters('syndicated_post_use_aggregator_source_data', ($ret=='yes'));
1496	}
1497
1498	/**
1499	* FeedWordPress::munge_permalinks: check whether or not FeedWordPress
1500	* should rewrite permalinks for syndicated items to reflect their
1501	* original location.
1502	*
1503	* @return bool TRUE if FeedWordPress SHOULD rewrite permalinks; FALSE otherwise
1504	*/
1505	/static/ function munge_permalinks () {
1506	return (get_option('feedwordpress_munge_permalink', /default=/ 'yes') != 'no');
1507	} /* FeedWordPress::munge_permalinks() */
1508
1509	function syndicated_links ($args = array()) {
1510	$contributors = FeedWordPress::link_category_id();
1511	if (!is_wp_error($contributors)) :
1512	$links = get_bookmarks(array_merge(
1513	array("category" => $contributors),
1514	$args
1515	));
1516	else :
1517	$links = array();
1518	endif;
1519	return $links;
1520	} // function FeedWordPress::syndicated_links()
1521
1522	function link_category_id () {
1523	global $wpdb, $wp_db_version;
1524
1525	$cat_id = get_option('feedwordpress_cat_id');
1526
1527	// If we don't yet have the category ID stored, search by name
1528	if (!$cat_id) :
1529	$cat_id = FeedWordPressCompatibility::link_category_id(DEFAULT_SYNDICATION_CATEGORY);
1530
1531	if ($cat_id) :
1532	// We found it; let's stamp it.
1533	update_option('feedwordpress_cat_id', $cat_id);
1534	endif;
1535
1536	// If we do have the category ID stored, verify that it exists
1537	else :
1538	$cat_id = FeedWordPressCompatibility::link_category_id((int) $cat_id, 'cat_id');
1539	endif;
1540
1541	// If we could not find an appropriate link category,
1542	// make a new one for ourselves.
1543	if (!$cat_id) :
1544	$cat_id = FeedWordPressCompatibility::insert_link_category(DEFAULT_SYNDICATION_CATEGORY);
1545	if (!is_wp_error($cat_id)) :
1546	// Stamp it
1547	update_option('feedwordpress_cat_id', $cat_id);
1548	endif;
1549	endif;
1550
1551	return $cat_id;
1552	} // function FeedWordPress::link_category_id()
1553
1554	# Upgrades and maintenance...
1555	function needs_upgrade () {
1556	global $wpdb;
1557	$fwp_db_version = get_option('feedwordpress_version');
1558	$ret = false; // innocent until proven guilty
1559	if (!$fwp_db_version or $fwp_db_version < FEEDWORDPRESS_VERSION) :
1560	// This is an older version or a fresh install. Does it
1561	// require a database upgrade or database initialization?
1562	if ($fwp_db_version <= 0.96) :
1563	// Yes. Check to see whether this is a fresh install or an upgrade.
1564	$syn = $wpdb->get_col("
1565	SELECT post_id
1566	FROM $wpdb->postmeta
1567	WHERE meta_key = 'syndication_feed'
1568	");
1569	if (count($syn) > 0) : // contains at least one syndicated post
1570	$ret = true;
1571	else : // fresh install; brand it as ours
1572	update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1573	endif;
1574	elseif ($fwp_db_version < 2009.0707) :
1575	// We need to clear out any busted AJAX crap
1576	$wpdb->query("
1577	DELETE FROM $wpdb->usermeta
1578	WHERE LOCATE('feedwordpress', meta_key)
1579	AND LOCATE('box', meta_key);
1580	");
1581
1582	update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1583	elseif ($fwp_db_version < 2010.0814) :
1584	// Change in terminology.
1585	if (get_option('feedwordpress_unfamiliar_category', 'create')=='default') :
1586	update_option('feedwordpress_unfamiliar_category', 'null');
1587	endif;
1588	foreach (FeedWordPress::syndicated_links() as $link) :
1589	$sub = new SyndicatedLink($link);
1590
1591	$remap_uf = array(
1592	'default' => 'null',
1593	'filter' => 'null',
1594	'create' => 'create:category',
1595	'tag' => 'create:post_tag'
1596	);
1597	if (isset($sub->settings['unfamiliar category'])) :
1598	if ($sub->settings['unfamiliar category']=='filter') :
1599	$sub->settings['match/filter'] = array('category');
1600	endif;
1601	foreach ($remap_uf as $from => $to) :
1602	if ($sub->settings['unfamiliar category']==$from) :
1603	$sub->settings['unfamiliar category'] = $to;
1604	endif;
1605	endforeach;
1606	endif;
1607
1608	if (isset($sub->settings['add global categories'])) :
1609	$sub->settings['add/category'] = $sub->settings['add global categories'];
1610	unset($sub->settings['add global categories']);
1611	endif;
1612
1613	$sub->save_settings(/reload=/ true);
1614	endforeach;
1615	update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1616	else :
1617	// No. Just brand it with the new version.
1618	update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1619	endif;
1620	endif;
1621	return $ret;
1622	}
1623
1624	function upgrade_database ($from = NULL) {
1625	global $wpdb;
1626
1627	if (is_null($from) or $from <= 0.96) : $from = 0.96; endif;
1628
1629	switch ($from) :
1630	case 0.96:
1631	// Dropping legacy upgrade code. If anyone is still
1632	// using 0.96 and just now decided to upgrade, well, I'm
1633	// sorry about that. You'll just have to cope with a few
1634	// duplicate posts.
1635
1636	// Mark the upgrade as successful.
1637	update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1638	endswitch;
1639	echo "<p>Upgrade complete. FeedWordPress is now ready to use again.</p>";
1640	} /* FeedWordPress::upgrade_database() */
1641
1642	function has_guid_index () {
1643	global $wpdb;
1644
1645	$found = false; // Guilty until proven innocent.
1646
1647	$results = $wpdb->get_results("
1648	SHOW INDEXES FROM {$wpdb->posts}
1649	");
1650	if ($results) :
1651	foreach ($results as $index) :
1652	if (isset($index->Column_name)
1653	and ('guid' == $index->Column_name)) :
1654	$found = true;
1655	endif;
1656	endforeach;
1657	endif;
1658	return $found;
1659	} /* FeedWordPress::has_guid_index () */
1660
1661	function create_guid_index () {
1662	global $wpdb;
1663
1664	$wpdb->query("
1665	CREATE INDEX {$wpdb->posts}_guid_idx ON {$wpdb->posts}(guid)
1666	");
1667	} /* FeedWordPress::create_guid_index () */
1668
1669	function remove_guid_index () {
1670	global $wpdb;
1671
1672	$wpdb->query("
1673	DROP INDEX {$wpdb->posts}_guid_idx ON {$wpdb->posts}
1674	");
1675	}
1676
1677	/static/ function fetch_timeout () {
1678	return apply_filters(
1679	'feedwordpress_fetch_timeout',
1680	intval(get_option('feedwordpress_fetch_timeout', FEEDWORDPRESS_FETCH_TIMEOUT_DEFAULT))
1681	);
1682	}
1683
1684	/static/ function fetch ($url, $params = array()) {
1685	if (is_wp_error($url)) :
1686	// Let's bounce.
1687	return $url;
1688	endif;
1689
1690	$force_feed = true; // Default
1691
1692	// Allow user to change default feed-fetch timeout with a global setting. Props Erigami Scholey-Fuller <http://www.piepalace.ca/blog/2010/11/feedwordpress-broke-my-heart.html> 'timeout' =>
1693	$timeout = FeedWordPress::fetch_timeout();
1694
1695	if (!is_array($params)) :
1696	$force_feed = $params;
1697	else : // Parameter array
1698	$args = wp_parse_args(array(
1699	'force_feed' => $force_feed,
1700	'timeout' => $timeout
1701	), $params);
1702
1703	extract($args);
1704	endif;
1705	$timeout = intval($timeout);
1706
1707	$pie_class = apply_filters('feedwordpress_simplepie_class', 'FeedWordPie');
1708	$cache_class = apply_filters('feedwordpress_cache_class', 'WP_Feed_Cache');
1709	$file_class = apply_filters('feedwordpress_file_class', 'FeedWordPress_File');
1710	$parser_class = apply_filters('feedwordpress_parser_class', 'FeedWordPress_Parser');
1711	$item_class = apply_filters('feedwordpress_item_class', 'FeedWordPie_Item');
1712	$sniffer_class = apply_filters('feedwordpress_sniffer_class', 'FeedWordPress_Content_Type_Sniffer');
1713
1714	$feed = new $pie_class;
1715	$feed->set_feed_url($url);
1716	$feed->set_cache_class($cache_class);
1717	$feed->set_timeout($timeout);
1718
1719	$feed->set_content_type_sniffer_class($sniffer_class);
1720	$feed->set_file_class($file_class);
1721	$feed->set_parser_class($parser_class);
1722	$feed->set_item_class($item_class);
1723	$feed->force_feed($force_feed);
1724	$feed->set_cache_duration(FeedWordPress::cache_duration($params));
1725	$feed->init();
1726	$feed->handle_content_type();
1727
1728	if ($feed->error()) :
1729	$ret = new WP_Error('simplepie-error', $feed->error());
1730	else :
1731	$ret = $feed;
1732	endif;
1733	return $ret;
1734	} /* FeedWordPress::fetch () */
1735
1736	function clear_cache () {
1737	global $wpdb;
1738
1739	// Just in case, clear out any old MagpieRSS cache records.
1740	$magpies = $wpdb->query("
1741	DELETE FROM {$wpdb->options}
1742	WHERE option_name LIKE 'rss_%' AND LENGTH(option_name) > 32
1743	");
1744
1745	// The WordPress SimplePie module stores its cached feeds as
1746	// transient records in the options table. The data itself is
1747	// stored in `_transient_feed_{md5 of url}` and the last-modified
1748	// timestamp in `_transient_feed_mod_{md5 of url}`. Timeouts for
1749	// these records are stored in `_transient_timeout_feed_{md5}`.
1750	// Since the md5 is always 32 characters in length, the
1751	// option_name is always over 32 characters.
1752	$simplepies = $wpdb->query("
1753	DELETE FROM {$wpdb->options}
1754	WHERE option_name LIKE '_transient%_feed_%' AND LENGTH(option_name) > 32
1755	");
1756	$simplepies = (int) ($simplepies / 4); // Each transient has 4 rows: the data, the modified timestamp; and the timeouts for each
1757
1758	return ($magpies + $simplepies);
1759	} /* FeedWordPress::clear_cache () */
1760
1761	function cache_duration ($params = array()) {
1762	$params = wp_parse_args($params, array(
1763	"cache" => true,
1764	));
1765
1766	$duration = NULL;
1767	if (!$params['cache']) :
1768	$duration = 0;
1769	elseif (defined('FEEDWORDPRESS_CACHE_AGE')) :
1770	$duration = FEEDWORDPRESS_CACHE_AGE;
1771	endif;
1772	return $duration;
1773	}
1774	function cache_lifetime ($duration) {
1775	// Check for explicit setting of a lifetime duration
1776	if (defined('FEEDWORDPRESS_CACHE_LIFETIME')) :
1777	$duration = FEEDWORDPRESS_CACHE_LIFETIME;
1778
1779	// Fall back to the cache freshness duration
1780	elseif (defined('FEEDWORDPRESS_CACHE_AGE')) :
1781	$duration = FEEDWORDPRESS_CACHE_AGE;
1782	endif;
1783
1784	// Fall back to WordPress default
1785	return $duration;
1786	} /* FeedWordPress::cache_lifetime () */
1787
1788	# Utility functions for handling text settings
1789	function negative ($f, $setting) {
1790	$nego = array ('n', 'no', 'f', 'false');
1791	return (isset($f[$setting]) and in_array(strtolower($f[$setting]), $nego));
1792	}
1793
1794	function affirmative ($f, $setting) {
1795	$affirmo = array ('y', 'yes', 't', 'true', 1);
1796	return (isset($f[$setting]) and in_array(strtolower($f[$setting]), $affirmo));
1797	}
1798
1799	# Internal debugging functions
1800	function critical_bug ($varname, $var, $line, $file = NULL) {
1801	global $wp_version;
1802
1803	if (!is_null($file)) :
1804	$location = "line # ${line} of ".basename($file);
1805	else :
1806	$location = "line # ${line}";
1807	endif;
1808
1809	print '<p><strong>Critical error:</strong> There may be a bug in FeedWordPress. Please <a href="'.FEEDWORDPRESS_AUTHOR_CONTACT.'">contact the author</a> and paste the following information into your e-mail:</p>';
1810	print "\n<plaintext>";
1811	print "Triggered at ${location}\n";
1812	print "FeedWordPress: ".FEEDWORDPRESS_VERSION."\n";
1813	print "WordPress: {$wp_version}\n";
1814	print "PHP: ".phpversion()."\n";
1815	print "Error data: ";
1816	print $varname.": "; var_dump($var); echo "\n";
1817	die;
1818	}
1819
1820	function noncritical_bug ($varname, $var, $line, $file = NULL) {
1821	if (FEEDWORDPRESS_DEBUG) : // halt only when we are doing debugging
1822	FeedWordPress::critical_bug($varname, $var, $line, $file);
1823	endif;
1824	}
1825
1826	function val ($v, $no_newlines = false) {
1827	ob_start();
1828	var_dump($v);
1829	$out = ob_get_contents(); ob_end_clean();
1830
1831	if ($no_newlines) :
1832	$out = preg_replace('/\s+/', " ", $out);
1833	endif;
1834	return $out;
1835	} /* FeedWordPress::val () */
1836
1837	function diagnostic_on ($level) {
1838	$show = get_option('feedwordpress_diagnostics_show', array());
1839	return (in_array($level, $show));
1840	} /* FeedWordPress::diagnostic_on () */
1841
1842	function diagnostic ($level, $out, $persist = NULL, $since = NULL, $mostRecent = NULL) {
1843	global $feedwordpress_admin_footer;
1844
1845	$output = get_option('feedwordpress_diagnostics_output', array());
1846	$dlog = get_option('feedwordpress_diagnostics_log', array());
1847
1848	$diagnostic_nesting = count(explode(":", $level));
1849
1850	if (FeedWordPress::diagnostic_on($level)) :
1851	foreach ($output as $method) :
1852	switch ($method) :
1853	case 'echo' :
1854	if (!FeedWordPress::update_requested()) :
1855	echo "<div><pre><strong>Diag".str_repeat('====', $diagnostic_nesting-1).'\|</strong> '.$out."</pre></div>";
1856	endif;
1857	break;
1858	case 'echo_in_cronjob' :
1859	if (FeedWordPress::update_requested()) :
1860	echo FeedWordPress::log_prefix()." ".$out."\n";
1861	endif;
1862	break;
1863	case 'admin_footer' :
1864	$feedwordpress_admin_footer[] = $out;
1865	break;
1866	case 'error_log' :
1867	error_log(FeedWordPress::log_prefix().' '.$out);
1868	break;
1869	case 'email' :
1870
1871	if (is_null($persist)) :
1872	$sect = 'occurrent';
1873	$hook = (isset($dlog['mesg'][$sect]) ? count($dlog['mesg'][$sect]) : 0);
1874	$line = array("Time" => time(), "Message" => $out);
1875	else :
1876	$sect = 'persistent';
1877	$hook = md5($level."\n".$persist);
1878	$line = array("Since" => $since, "Message" => $out, "Most Recent" => $mostRecent);
1879	endif;
1880
1881	if (!isset($dlog['mesg'])) : $dlog['mesg'] = array(); endif;
1882	if (!isset($dlog['mesg'][$sect])) : $dlog['mesg'][$sect] = array(); endif;
1883
1884	$dlog['mesg'][$sect][$hook] = $line;
1885	endswitch;
1886	endforeach;
1887	endif;
1888
1889	update_option('feedwordpress_diagnostics_log', $dlog);
1890	} /* FeedWordPress::diagnostic () */
1891
1892	function email_diagnostics_override () {
1893	return ($this->has_secret() and isset($_REQUEST['feedwordpress_email_diagnostics']) and !!$_REQUEST['feedwordpress_email_diagnostics']);
1894	}
1895	function has_emailed_diagnostics ($dlog) {
1896	$ret = false;
1897	if ($this->email_diagnostics_override()
1898	or (isset($dlog['schedule']) and isset($dlog['schedule']['last']))) :
1899	$ret = true;
1900	endif;
1901	return $ret;
1902	}
1903	function ready_to_email_diagnostics ($dlog) {
1904	$ret = false;
1905	if ($this->email_diagnostics_override()
1906	or (time() > ($dlog['schedule']['last'] + $dlog['schedule']['freq']))) :
1907	$ret = true;
1908	endif;
1909	return $ret;
1910	}
1911
1912	function email_diagnostic_log ($params = array()) {
1913	$params = wp_parse_args($params, array(
1914	"force" => false,
1915	));
1916
1917	$dlog = get_option('feedwordpress_diagnostics_log', array());
1918
1919	if ($this->has_emailed_diagnostics($dlog)) :
1920	if ($this->ready_to_email_diagnostics($dlog)) :
1921	// No news is good news; only send if
1922	// there are some messages to send.
1923	$body = NULL;
1924	if (!isset($dlog['mesg'])) : $dlog['mesg'] = array(); endif;
1925
1926	foreach ($dlog['mesg'] as $sect => $mesgs) :
1927	if (count($mesgs) > 0) :
1928	if (is_null($body)) : $body = ''; endif;
1929
1930	$paradigm = reset($mesgs);
1931	$body .= "<h2>".ucfirst($sect)." issues</h2>\n"
1932	."<table>\n"
1933	."<thead><tr>\n";
1934	foreach ($paradigm as $col => $value) :
1935	$body .= '<th scope="col">'.$col."</th>\n";
1936	endforeach;
1937	$body .= "</tr></thead>\n"
1938	."<tbody>\n";
1939
1940	foreach ($mesgs as $line) :
1941	$body .= "<tr>\n";
1942	foreach ($line as $col => $cell) :
1943	if (is_numeric($cell)) :
1944	$cell = date('j-M-y, h:i a', $cell);
1945	endif;
1946	$class = strtolower(preg_replace('/\s+/', '-', $col));
1947	$body .= "<td class=\"$class\">${cell}</td>";
1948	endforeach;
1949	$body .= "</tr>\n";
1950	endforeach;
1951
1952	$body .= "</tbody>\n</table>\n\n";
1953	endif;
1954	endforeach;
1955
1956	$body = apply_filters('feedwordpress_diagnostic_email_body', $body, $dlog);
1957	if (!is_null($body)) :
1958	$home = feedwordpress_display_url(get_bloginfo('url'));
1959	$subj = apply_filters('feedwordpress_diagnostic_email_subject', $home . " syndication issues", $dlog);
1960	$agent = 'FeedWordPress '.FEEDWORDPRESS_VERSION;
1961	$body = <<<EOMAIL
1962	<html>
1963	<head>
1964	<title>$subj</title>
1965	<style type="text/css">
1966	body { background-color: white; color: black; }
1967	table { width: 100%; border: 1px solid black; }
1968	table thead tr th { background-color: #ff7700; color: white; border-bottom: 1px solid black; }
1969	table thead tr { border-bottom: 1px solid black; }
1970	table tr { vertical-align: top; }
1971	table .since { width: 20%; }
1972	table .time { width: 20%; }
1973	table .most-recently { width: 20%; }
1974	table .message { width: auto; }
1975	</style>
1976	</head>
1977	<body>
1978	<h1>Syndication Issues encountered by $agent on $home</h1>
1979	$body
1980	</body>
1981	</html>
1982
1983	EOMAIL;
1984
1985	$ded = get_option('feedwordpress_diagnostics_email_destination', 'admins');
1986
1987	// e-mail address
1988	if (preg_match('/^mailto:(.*)$/', $ded, $ref)) :
1989	$recipients = array($ref[1]);
1990
1991	// userid
1992	elseif (preg_match('/^user:(.*)$/', $ded, $ref)) :
1993	$userdata = get_userdata((int) $ref[1]);
1994	$recipients = array($userdata->user_email);
1995
1996	// admins
1997	else :
1998	$recipients = FeedWordPressDiagnostic::admin_emails();
1999	endif;
2000
2001	$mesgId = 'feedwordpress+'.time().'@'.$home;
2002	$parentId = get_option('feedwordpress_diagnostics_email_root_message_id', NULL);
2003
2004	$head = array("Message-ID: <$mesgId>");
2005	if (!is_null($parentId)) :
2006	// We've already sent off a diagnostic message in the past. Let's do some
2007	// magic to help with threading, in the hopes that all diagnostic messages
2008	// get threaded together.
2009	$head[] = "References: <$parentId>";
2010	$head[] = "In-Reply-To: <$parentId>";
2011	$subj = "Re: ".$subj;
2012	else :
2013	// This is the first of its kind. Let's mark it as such.
2014	update_option('feedwordpress_diagnostics_email_root_message_id', $mesgId);
2015	endif;
2016	$head = apply_filters('feedwordpress_diagnostic_email_headers', $head);
2017
2018	foreach ($recipients as $email) :
2019	add_filter('wp_mail_content_type', array('FeedWordPress', 'allow_html_mail'));
2020	wp_mail($email, $subj, $body, $head);
2021	remove_filter('wp_mail_content_type', array('FeedWordPress', 'allow_html_mail'));
2022	endforeach;
2023	endif;
2024
2025	// Clear the logs
2026	$dlog['mesg']['persistent'] = array();
2027	$dlog['mesg']['occurrent'] = array();
2028
2029	// Set schedule for next update
2030	$dlog['schedule']['last'] = time();
2031	endif;
2032	else :
2033	$dlog['schedule'] = array(
2034	'freq' => 24 /hr/ * 60 /min/ * 60 /s/,
2035	'last' => time(),
2036	);
2037	endif;
2038
2039	update_option('feedwordpress_diagnostics_log', $dlog);
2040	} /* FeedWordPress::email_diagnostic_log () */
2041
2042	function allow_html_mail () {
2043	return 'text/html';
2044	} /* FeedWordPress::allow_html_mail () */
2045
2046	function admin_footer () {
2047	global $feedwordpress_admin_footer;
2048	foreach ($feedwordpress_admin_footer as $line) :
2049	echo '<div><pre>'.$line.'</pre></div>';
2050	endforeach;
2051	} /* FeedWordPress::admin_footer () */
2052
2053	function log_prefix ($date = false) {
2054	$home = get_bloginfo('url');
2055	$prefix = '['.feedwordpress_display_url($home).'] [feedwordpress] ';
2056	if ($date) :
2057	$prefix = "[".date('Y-m-d H:i:s')."]".$prefix;
2058	endif;
2059	return $prefix;
2060	} /* FeedWordPress::log_prefix () */
2061
2062	function menu_cap ($sub = false) {
2063	if ($sub) :
2064	$cap = apply_filters('feedwordpress_menu_settings_capacity', 'manage_options');
2065	else :
2066	$cap = apply_filters('feedwordpress_menu_main_capacity', 'manage_links');
2067	endif;
2068	return $cap;
2069	} /* FeedWordPress::menu_cap () */
2070
2071	function path ($filename = '') {
2072	global $fwp_path;
2073
2074	$path = $fwp_path;
2075	if (strlen($filename) > 0) :
2076	$path .= '/'.$filename;
2077	endif;
2078	return $path;
2079	}
2080
2081	function param ($key, $type = 'REQUEST', $default = NULL) {
2082	$where = '_'.strtoupper($type);
2083	$ret = $default;
2084	if (isset($GLOBALS[$where]) and is_array($GLOBALS[$where])) :
2085	if (isset($GLOBALS[$where][$key])) :
2086	$ret = $GLOBALS[$where][$key];
2087	if (get_magic_quotes_gpc()) :
2088	$ret = stripslashes_deep($ret);
2089	endif;
2090	endif;
2091	endif;
2092	return $ret;
2093	}
2094	function post ($key, $default = NULL) {
2095	return FeedWordPress::param($key, 'POST');
2096	}
2097	} // class FeedWordPress
2098
2099	$feedwordpress_admin_footer = array();
2100
2101	// take your best guess at the realname and e-mail, given a string
2102	define('FWP_REGEX_EMAIL_ADDY', '([^@"(<\s]+@[^"@(<\s]+\.[^"@(<\s]+)');
2103	define('FWP_REGEX_EMAIL_NAME', '("([^"]*)"\|([^"<(]+\S))');
2104	define('FWP_REGEX_EMAIL_POSTFIX_NAME', '/^\s'.FWP_REGEX_EMAIL_ADDY."\s+$".FWP_REGEX_EMAIL_NAME.'$\s$/');
2105	define('FWP_REGEX_EMAIL_PREFIX_NAME', '/^\s'.FWP_REGEX_EMAIL_NAME.'\s<'.FWP_REGEX_EMAIL_ADDY.'>\s*$/');
2106	define('FWP_REGEX_EMAIL_JUST_ADDY', '/^\s'.FWP_REGEX_EMAIL_ADDY.'\s$/');
2107	define('FWP_REGEX_EMAIL_JUST_NAME', '/^\s'.FWP_REGEX_EMAIL_NAME.'\s$/');
2108
2109	function parse_email_with_realname ($email) {
2110	if (preg_match(FWP_REGEX_EMAIL_POSTFIX_NAME, $email, $matches)) :
2111	($ret['name'] = $matches[3]) or ($ret['name'] = $matches[2]);
2112	$ret['email'] = $matches[1];
2113	elseif (preg_match(FWP_REGEX_EMAIL_PREFIX_NAME, $email, $matches)) :
2114	($ret['name'] = $matches[2]) or ($ret['name'] = $matches[3]);
2115	$ret['email'] = $matches[4];
2116	elseif (preg_match(FWP_REGEX_EMAIL_JUST_ADDY, $email, $matches)) :
2117	$ret['name'] = NULL; $ret['email'] = $matches[1];
2118	elseif (preg_match(FWP_REGEX_EMAIL_JUST_NAME, $email, $matches)) :
2119	$ret['email'] = NULL;
2120	($ret['name'] = $matches[2]) or ($ret['name'] = $matches[3]);
2121	else :
2122	$ret['name'] = NULL; $ret['email'] = NULL;
2123	endif;
2124	return $ret;
2125	}
2126
2127