feedwordpress / feedwordpress.php

feedwordpress.php in FeedWordPress 2016.1211, at feedwordpress.php

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