feedwordpress / feedwordpress.php

feedwordpress.php in FeedWordPress 2015.0514, at feedwordpress.php

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