PluginProbe
FeedWordPress / 2010.0602
FeedWordPress v2010.0602
trunk 0.8 0.9 0.91 0.95 0.96 0.97 0.98 0.981 0.99 0.991 0.992 0.993 2008.1030 2008.1101 2008.1105 2008.1214 2009.0612 2009.0613 2009.0618 2009.0707 2009.1111 2009.1112 2010.0127 2010.0528 All 65 releases
← All changes | feedwordpress.php +753 -2027 2008.1105 → 2010.0602 View file →
@@ -1,16 +1,20 @@
1 1 <?php
2 2 /*
3 3 Plugin Name: FeedWordPress
4 -Plugin URI: http://projects.radgeek.com/feedwordpress
4 +Plugin URI: http://feedwordpress.radgeek.com/
5 5 Description: simple and flexible Atom/RSS syndication for WordPress
6 -Version: 2008.1105
6 +Version: 2010.0602
7 7 Author: Charles Johnson
8 8 Author URI: http://radgeek.com/
9 9 License: GPL
10 -Last modified: 2008-11-05 4:35pm PST
11 10 */
12 11
12 +/**
13 + * @package FeedWordPress
14 + * @version 2010.0602
15 + */
16 +
13 17 # This uses code derived from:
14 18 # - wp-rss-aggregate.php by Kellan Elliot-McCrea <kellan@protest.net>
15 19 # - HTTP Navigator 2 by Keyvan Minoukadeh <keyvan@k1m.com>
16 20 # - Ultra-Liberal Feed Finder by Mark Pilgrim <mark@diveintomark.org>
@@ -15,24 +19,37 @@
15 19 # - HTTP Navigator 2 by Keyvan Minoukadeh <keyvan@k1m.com>
16 20 # - Ultra-Liberal Feed Finder by Mark Pilgrim <mark@diveintomark.org>
17 21 # according to the terms of the GNU General Public License.
18 22 #
19 -# INSTALLATION: see README.text or <http://projects.radgeek.com/install>
23 +# INSTALLATION: see readme.txt or <http://projects.radgeek.com/install>
20 24 #
21 25 # USAGE: once FeedWordPress is installed, you manage just about everything from
22 -# the WordPress Dashboard, under Options --> Syndication or Links --> Syndicated
23 -# To ensure that fresh content is added as it becomes available, get your
24 -# contributors to put your XML-RPC URI (if WordPress is installed at
26 +# the WordPress Dashboard, under the Syndication menu. To ensure that fresh
27 +# content is added as it becomes available, you can convince your contributors
28 +# to put your XML-RPC URI (if WordPress is installed at
25 29 # <http://www.zyx.com/blog>, XML-RPC requests should be sent to
26 -# <http://www.zyx.com/blog/xmlrpc.php>), or see `update-feeds.php`
30 +# <http://www.zyx.com/blog/xmlrpc.php>), or update manually under the
31 +# Syndication menu, or set up automatic updates under Syndication --> Settings,
32 +# or use a cron job.
27 33
28 34 # -- Don't change these unless you know what you're doing...
29 35
30 -define ('FEEDWORDPRESS_VERSION', '2008.1105');
36 +define ('FEEDWORDPRESS_VERSION', '2010.0602');
31 37 define ('FEEDWORDPRESS_AUTHOR_CONTACT', 'http://radgeek.com/contact');
38 +
39 +// Defaults
32 40 define ('DEFAULT_SYNDICATION_CATEGORY', 'Contributors');
41 +define ('DEFAULT_UPDATE_PERIOD', 60); // value in minutes
33 42
34 -define ('FEEDWORDPRESS_DEBUG', false);
43 +if (isset($_REQUEST['feedwordpress_debug'])) :
44 + $feedwordpress_debug = $_REQUEST['feedwordpress_debug'];
45 +else :
46 + $feedwordpress_debug = get_option('feedwordpress_debug');
47 + if (is_string($feedwordpress_debug)) :
48 + $feedwordpress_debug = ($feedwordpress_debug == 'yes');
49 + endif;
50 +endif;
51 +define ('FEEDWORDPRESS_DEBUG', $feedwordpress_debug);
35 52
36 53 define ('FEEDWORDPRESS_CAT_SEPARATOR_PATTERN', '/[:\n]/');
37 54 define ('FEEDWORDPRESS_CAT_SEPARATOR', "\n");
38 55
@@ -40,19 +57,23 @@
40 57
41 58 define ('FEEDWORDPRESS_FRESHNESS_INTERVAL', 10*60); // Every ten minutes
42 59
43 60 define ('FWP_SCHEMA_HAS_USERMETA', 2966);
61 +define ('FWP_SCHEMA_USES_ARGS_TAXONOMY', 12694); // Revision # for using $args['taxonomy'] to get link categories
44 62 define ('FWP_SCHEMA_20', 3308); // Database schema # for WP 2.0
45 63 define ('FWP_SCHEMA_21', 4772); // Database schema # for WP 2.1
46 64 define ('FWP_SCHEMA_23', 5495); // Database schema # for WP 2.3
47 65 define ('FWP_SCHEMA_25', 7558); // Database schema # for WP 2.5
48 66 define ('FWP_SCHEMA_26', 8201); // Database schema # for WP 2.6
67 +define ('FWP_SCHEMA_27', 9872); // Database schema # for WP 2.7
68 +define ('FWP_SCHEMA_28', 11548); // Database schema # for WP 2.8
69 +define ('FWP_SCHEMA_29', 12329); // Database schema # for WP 2.9
70 +define ('FWP_SCHEMA_30', 12694); // Database schema # for WP 3.0
49 71
50 72 if (FEEDWORDPRESS_DEBUG) :
51 73 // Help us to pick out errors, if any.
52 74 ini_set('error_reporting', E_ALL & ~E_NOTICE);
53 75 ini_set('display_errors', true);
54 - define('MAGPIE_DEBUG', true);
55 76
56 77 // When testing we don't want cache issues to interfere. But this is
57 78 // a VERY BAD SETTING for a production server. Webmasters will eat your
58 79 // face for breakfast if you use it, and the baby Jesus will cry. So
@@ -57,22 +78,25 @@
57 78 // a VERY BAD SETTING for a production server. Webmasters will eat your
58 79 // face for breakfast if you use it, and the baby Jesus will cry. So
59 80 // make sure FEEDWORDPRESS_DEBUG is FALSE for any site that will be
60 81 // used for more than testing purposes!
61 - define('MAGPIE_CACHE_AGE', 1);
82 + define('FEEDWORDPRESS_CACHE_AGE', 1);
83 + define('FEEDWORDPRESS_CACHE_LIFETIME', 1);
84 + define('FEEDWORDPRESS_FETCH_TIME_OUT', 60);
62 85 else :
63 - define('MAGPIE_DEBUG', false);
86 + // Hold onto data all day for conditional GET purposes,
87 + // but consider it stale after 1 min (requiring a conditional GET)
88 + define('FEEDWORDPRESS_CACHE_LIFETIME', 24*60*60);
89 + define('FEEDWORDPRESS_CACHE_AGE', 1*60);
90 + define('FEEDWORDPRESS_FETCH_TIME_OUT', 10);
64 91 endif;
65 92
66 -// Note that the rss-functions.php that comes prepackaged with WordPress is
67 -// old & busted. For the new hotness, drop a copy of rss.php from
68 -// this archive into wp-includes/rss.php
93 +// Use our the cache settings that we want.
94 +add_filter('wp_feed_cache_transient_lifetime', array('FeedWordPress', 'cache_lifetime'));
69 95
70 -if (is_readable(ABSPATH . WPINC . '/rss.php')) :
71 - require_once (ABSPATH . WPINC . '/rss.php');
72 -else :
73 - require_once (ABSPATH . WPINC . '/rss-functions.php');
74 -endif;
96 +// Ensure that we have SimplePie loaded up and ready to go.
97 +// We no longer need a MagpieRSS upgrade module. Hallelujah!
98 +require_once(ABSPATH . WPINC . '/feed.php');
75 99
76 100 if (isset($wp_db_version)) :
77 101 if ($wp_db_version >= FWP_SCHEMA_23) :
78 102 require_once (ABSPATH . WPINC . '/registration.php'); // for wp_insert_user
@@ -84,9 +108,12 @@
84 108 require_once (ABSPATH . 'wp-admin/admin-db.php'); // for wp_insert_category
85 109 endif;
86 110 endif;
87 111
112 +require_once (ABSPATH . WPINC . '/class-feed.php');
88 113 require_once(dirname(__FILE__) . '/compatability.php'); // LEGACY API: Replicate or mock up functions for legacy support purposes
114 +require_once(dirname(__FILE__) . '/feedwordpresshtml.class.php');
115 +require_once(dirname(__FILE__) . '/feedwordpress-content-type-sniffer.class.php');
89 116
90 117 // Magic quotes are just about the stupidest thing ever.
91 118 if (is_array($_POST)) :
92 119 $fwp_post = stripslashes_deep($_POST);
@@ -104,25 +131,31 @@
104 131 else : // Something went wrong. Let's just guess.
105 132 $fwp_path = 'feedwordpress';
106 133 endif;
107 134
135 +function feedwordpress_admin_scripts () {
136 + global $fwp_path;
137 +
138 + wp_enqueue_script('post'); // for magic tag and category boxes
139 + if (!FeedWordPressCompatibility::test_version(FWP_SCHEMA_29)) : // < 2.9
140 + wp_enqueue_script('thickbox'); // for fold-up boxes
141 + endif;
142 + wp_enqueue_script('admin-forms'); // for checkbox selection
143 +
144 + wp_register_script('feedwordpress-elements', WP_PLUGIN_URL.'/'.$fwp_path.'/feedwordpress-elements.js');
145 + wp_enqueue_script('feedwordpress-elements');
146 +}
147 +
108 148 // If this is a FeedWordPress admin page, queue up scripts for AJAX functions that FWP uses
109 149 // If it is a display page or a non-FeedWordPress admin page, don't.
110 150 if (is_admin() and isset($_REQUEST['page']) and preg_match("|^{$fwp_path}/|", $_REQUEST['page'])) :
111 - if (function_exists('wp_enqueue_script')) :
112 - if (isset($wp_db_version) and $wp_db_version >= FWP_SCHEMA_25) :
113 - wp_enqueue_script('post'); // for magic tag and category boxes
114 - wp_enqueue_script('thickbox'); // for fold-up boxes
115 - wp_enqueue_script('admin-forms'); // for checkbox selection
116 - else :
117 - wp_enqueue_script( 'ajaxcat' ); // Provides the handy-dandy new category text box
118 - endif;
119 - endif;
120 - if (function_exists('wp_enqueue_style')) :
121 - if (fwp_test_wp_version(FWP_SCHEMA_25)) :
122 - wp_enqueue_style('dashboard');
123 - endif;
124 - endif;
151 + add_action('admin_print_scripts', 'feedwordpress_admin_scripts');
152 +
153 + wp_register_style('feedwordpress-elements', WP_PLUGIN_URL.'/'.$fwp_path.'/feedwordpress-elements.css');
154 +
155 + wp_enqueue_style('dashboard');
156 + wp_enqueue_style('feedwordpress-elements');
157 +
125 158 if (function_exists('wp_admin_css')) :
126 159 if (fwp_test_wp_version(FWP_SCHEMA_25)) :
127 160 wp_admin_css('css/dashboard');
128 161 endif;
@@ -151,8 +184,15 @@
151 184
152 185 # Filter in original permalinks if the user wants that
153 186 add_filter('post_link', 'syndication_permalink', 1);
154 187
188 + # When foreign URLs are used for permalinks in feeds or display
189 + # contexts, they need to be escaped properly.
190 + add_filter('the_permalink', 'syndication_permalink_escaped');
191 + add_filter('the_permalink_rss', 'syndication_permalink_escaped');
192 +
193 + add_filter('post_comments_feed_link', 'syndication_comments_feed_link');
194 +
155 195 # WTF? By default, wp_insert_link runs incoming link_url and link_rss
156 196 # URIs through default filters that include `wp_kses()`. But `wp_kses()`
157 197 # just happens to escape any occurrence of & to &amp; -- which just
158 198 # happens to fuck up any URI with a & to separate GET parameters.
@@ -160,8 +200,14 @@
160 200 remove_filter('pre_link_url', 'wp_filter_kses');
161 201
162 202 # Admin menu
163 203 add_action('admin_menu', 'fwp_add_pages');
204 + add_action('admin_notices', 'fwp_check_debug');
205 +
206 + add_action('admin_menu', 'feedwordpress_add_post_edit_controls');
207 + add_action('save_post', 'feedwordpress_save_post_edit_controls');
208 +
209 + add_action('admin_footer', array('FeedWordPress', 'admin_footer'));
164 210
165 211 # Inbound XML-RPC update methods
166 212 add_filter('xmlrpc_methods', 'feedwordpress_xmlrpc_hook');
167 213
@@ -183,13 +229,32 @@
183 229 add_action('feedwordpress_update', 'log_feedwordpress_update_feeds', 100);
184 230 add_action('feedwordpress_check_feed', 'log_feedwordpress_check_feed', 100);
185 231 add_action('feedwordpress_update_complete', 'log_feedwordpress_update_complete', 100);
186 232 endif;
187 -
233 +
234 + if (FeedWordPress::update_requested()) :
235 + if (FEEDWORDPRESS_DEBUG) :
236 + add_action('post_syndicated_item', 'debug_out_feedwordpress_post', 100);
237 + add_action('update_syndicated_item', 'debug_out_feedwordpress_update_post', 100);
238 + add_action('feedwordpress_update', 'debug_out_feedwordpress_update_feeds', 100);
239 + add_action('feedwordpress_check_feed', 'debug_out_feedwordpress_check_feed', 100);
240 + add_action('feedwordpress_update_complete', 'debug_out_feedwordpress_update_complete', 100);
241 + endif;
242 +
243 + add_action('feedwordpress_check_feed_complete', 'debug_out_feedwordpress_feed_error', 100, 3);
244 + endif;
245 +
188 246 # Cron-less auto-update. Hooray!
189 - add_action('init', 'feedwordpress_auto_update');
190 -
247 + $autoUpdateHook = get_option('feedwordpress_automatic_updates');
248 + if ($autoUpdateHook != 'init') :
249 + $autoUpdateHook = 'shutdown';
250 + endif;
251 + add_action($autoUpdateHook, 'feedwordpress_auto_update');
252 +
253 + add_action('init', 'feedwordpress_update_magic_url');
254 +
191 255 # Default sanitizers
256 + add_filter('syndicated_item_content', array('SyndicatedPost', 'resolve_relative_uris'), 0, 2);
192 257 add_filter('syndicated_item_content', array('SyndicatedPost', 'sanitize_content'), 0, 2);
193 258
194 259 else :
195 260 # Hook in the menus, which will just point to the upgrade interface
@@ -197,16 +262,46 @@
197 262 endif; // if (!FeedWordPress::needs_upgrade())
198 263
199 264 function feedwordpress_auto_update () {
200 265 if (FeedWordPress::stale()) :
201 - $feedwordpress =& new FeedWordPress;
266 + $feedwordpress = new FeedWordPress;
202 267 $feedwordpress->update();
203 268 endif;
204 -
269 +} /* feedwordpress_auto_update () */
270 +
271 +function feedwordpress_update_magic_url () {
272 + global $wpdb;
273 +
274 + // Explicit update request in the HTTP request (e.g. from a cron job)
205 275 if (FeedWordPress::update_requested()) :
276 + $feedwordpress = new FeedWordPress;
277 + $feedwordpress->update(FeedWordPress::update_requested_url());
278 +
279 + if (FEEDWORDPRESS_DEBUG and count($wpdb->queries) > 0) :
280 + $mysqlTime = 0.0;
281 + $byTime = array();
282 + foreach ($wpdb->queries as $query) :
283 + $time = $query[1] * 1000000.0;
284 + $mysqlTime += $query[1];
285 + if (!isset($byTime[$time])) : $byTime[$time] = array(); endif;
286 + $byTime[$time][] = $query[0]. ' // STACK: ' . $query[2];
287 + endforeach;
288 + krsort($byTime);
289 +
290 + foreach ($byTime as $time => $querySet) :
291 + foreach ($querySet as $query) :
292 + print "[".(sprintf('%4.4f', $time/1000.0)) . "ms] $query\n";
293 + endforeach;
294 + endforeach;
295 + echo "[feedwordpress] $wpdb->num_queries queries. $mysqlTime seconds in MySQL. Total of "; timer_stop(1); print " seconds.";
296 + endif;
297 +
298 +
299 + // Magic URL should return nothing but a 200 OK header packet
300 + // when successful.
206 301 exit;
207 302 endif;
208 -} /* feedwordpress_auto_update () */
303 +} /* feedwordpress_magic_update_url () */
209 304
210 305 ################################################################################
211 306 ## LOGGING FUNCTIONS: log status updates to error_log if you want it ###########
212 307 ################################################################################
@@ -243,23 +338,76 @@
243 338 .(is_null($delta) ? "Error: I don't syndicate that URI"
244 339 : implode(' and ', $mesg)));
245 340 }
246 341
342 +function debug_out_feedwordpress_post ($id) {
343 + $post = wp_get_single_post($id);
344 + print ("[".date('Y-m-d H:i:s')."][feedwordpress] posted "
345 + ."'{$post->post_title}' ({$post->post_date})\n");
346 +}
347 +
348 +function debug_out_feedwordpress_update_post ($id) {
349 + $post = wp_get_single_post($id);
350 + print ("[".date('Y-m-d H:i:s')."][feedwordpress] updated "
351 + ."'{$post->post_title}' ({$post->post_date})"
352 + ." (as of {$post->post_modified})\n");
353 +}
354 +
355 +function debug_out_feedwordpress_update_feeds ($uri) {
356 + print ("[".date('Y-m-d H:i:s')."][feedwordpress] update('$uri')\n");
357 +}
358 +
359 +function debug_out_feedwordpress_check_feed ($feed) {
360 + $uri = $feed['link/uri']; $name = $feed['link/name'];
361 + print ("[".date('Y-m-d H:i:s')."][feedwordpress] Examining $name <$uri>\n");
362 +}
363 +
364 +function debug_out_feedwordpress_update_complete ($delta) {
365 + $mesg = array();
366 + if (isset($delta['new'])) $mesg[] = 'added '.$delta['new'].' new posts';
367 + if (isset($delta['updated'])) $mesg[] = 'updated '.$delta['updated'].' existing posts';
368 + if (empty($mesg)) $mesg[] = 'nothing changed';
369 +
370 + print ("[".date('Y-m-d H:i:s')."][feedwordpress] "
371 + .(is_null($delta) ? "Error: I don't syndicate that URI"
372 + : implode(' and ', $mesg))."\n");
373 +}
374 +
375 +function debug_out_feedwordpress_feed_error ($feed, $added, $dt) {
376 + if (is_wp_error($added)) :
377 + $mesgs = $added->get_error_messages();
378 + foreach ($mesgs as $mesg) :
379 + echo "[feedwordpress] Error updating [{$feed['link/uri']}]: $mesg\n";
380 + endforeach;
381 + endif;
382 +}
383 +
247 384 ################################################################################
248 385 ## TEMPLATE API: functions to make your templates syndication-aware ############
249 386 ################################################################################
250 387
251 -function is_syndicated () { return (strlen(get_syndication_feed_id()) > 0); }
388 +/**
389 + * is_syndicated: Tests whether the current post in a Loop context, or a post
390 + * given by ID number, was syndicated by FeedWordPress. Useful for templates
391 + * to determine whether or not to retrieve syndication-related meta-data in
392 + * displaying a post.
393 + *
394 + * @param int $id The post to check for syndicated status. Defaults to the current post in a Loop context.
395 + * @return bool TRUE if the post's meta-data indicates it was syndicated; FALSE otherwise
396 + */
397 +function is_syndicated ($id = NULL) {
398 + return (strlen(get_syndication_feed_id($id)) > 0);
399 +} /* function is_syndicated() */
252 400
253 -function get_syndication_source_link ($original = NULL) {
401 +function get_syndication_source_link ($original = NULL, $id = NULL) {
254 402 if (is_null($original)) : $original = FeedWordPress::use_aggregator_source_data();
255 403 endif;
256 404
257 - if ($original) : $vals = get_post_custom_values('syndication_source_uri_original');
405 + if ($original) : $vals = get_post_custom_values('syndication_source_uri_original', $id);
258 406 else : $vals = array();
259 407 endif;
260 408
261 - if (count($vals) == 0) : $vals = get_post_custom_values('syndication_source_uri');
409 + if (count($vals) == 0) : $vals = get_post_custom_values('syndication_source_uri', $id);
262 410 endif;
263 411
264 412 if (count($vals) > 0) : $ret = $vals[0]; else : $ret = NULL; endif;
265 413
@@ -265,37 +413,72 @@
265 413
266 414 return $ret;
267 415 } /* function get_syndication_source_link() */
268 416
269 -function the_syndication_source_link ($original = NULL) { echo get_syndication_source_link($original); }
417 +function the_syndication_source_link ($original = NULL, $id = NULL) {
418 + echo get_syndication_source_link($original, $id);
419 +}
270 420
271 -function get_syndication_source ($original = NULL) {
272 - if (is_null($original)) : $original = FeedWordPress::use_aggregator_source_data();
421 +function feedwordpress_display_url ($url, $before = 60, $after = 0) {
422 + $bits = parse_url($url);
423 +
424 + // Strip out crufty subdomains
425 + $bits['host'] = preg_replace('/^www[0-9]*\./i', '', $bits['host']);
426 +
427 + // Reassemble bit-by-bit with minimum of crufty elements
428 + $url = (isset($bits['user'])?$bits['user'].'@':'')
429 + .(isset($bits['host'])?$bits['host']:'')
430 + .(isset($bits['path'])?$bits['path']:'')
431 + .(isset($uri_bits['port'])?':'.$uri_bits['port']:'')
432 + .(isset($bits['query'])?'?'.$bits['query']:'');
433 +
434 + if (strlen($url) > ($before+$after)) :
435 + $url = substr($url, 0, $before).'…'.substr($url, 0 - $after, $after);
273 436 endif;
274 437
275 - if ($original) : $vals = get_post_custom_values('syndication_source_original');
276 - else : $vals = array();
438 + return $url;
439 +}
440 +
441 +function get_syndication_source ($original = NULL, $id = NULL) {
442 + if (is_null($original)) :
443 + $original = FeedWordPress::use_aggregator_source_data();
277 444 endif;
445 +
446 + if ($original) :
447 + $vals = get_post_custom_values('syndication_source_original', $id);
448 + else :
449 + $vals = array();
450 + endif;
278 451
279 - if (count($vals) == 0) : $vals = get_post_custom_values('syndication_source');
452 + if (count($vals) == 0) :
453 + $vals = get_post_custom_values('syndication_source', $id);
280 454 endif;
281 455
282 - if (count($vals) > 0) : $ret = $vals[0]; else : $ret = NULL; endif;
456 + if (count($vals) > 0) :
457 + $ret = $vals[0];
458 + else :
459 + $ret = NULL;
460 + endif;
283 461
462 + if (is_null($ret) or strlen(trim($ret)) == 0) :
463 + // Fall back to URL of blog
464 + $ret = feedwordpress_display_url(get_syndication_source_link());
465 + endif;
466 +
284 467 return $ret;
285 468 } /* function get_syndication_source() */
286 469
287 -function the_syndication_source ($original = NULL) { echo get_syndication_source($original); }
470 +function the_syndication_source ($original = NULL, $id = NULL) { echo get_syndication_source($original, $id); }
288 471
289 -function get_syndication_feed ($original = NULL) {
472 +function get_syndication_feed ($original = NULL, $id = NULL) {
290 473 if (is_null($original)) : $original = FeedWordPress::use_aggregator_source_data();
291 474 endif;
292 475
293 - if ($original) : $vals = get_post_custom_values('syndication_feed_original');
476 + if ($original) : $vals = get_post_custom_values('syndication_feed_original', $id);
294 477 else : $vals = array();
295 478 endif;
296 -
297 - if (count($vals) == 0) : $vals = get_post_custom_values('syndication_feed');
479 +
480 + if (count($vals) == 0) : $vals = get_post_custom_values('syndication_feed', $id);
298 481 endif;
299 482
300 483 if (count($vals) > 0) : $ret = $vals[0]; else : $ret = NULL; endif;
301 484
@@ -301,19 +484,19 @@
301 484
302 485 return $ret;
303 486 } /* function get_syndication_feed() */
304 487
305 -function the_syndication_feed ($original = NULL) { echo get_syndication_feed ($original); }
488 +function the_syndication_feed ($original = NULL, $id = NULL) { echo get_syndication_feed($original, $id); }
306 489
307 -function get_syndication_feed_guid ($original = NULL) {
490 +function get_syndication_feed_guid ($original = NULL, $id = NULL) {
308 491 if (is_null($original)) : $original = FeedWordPress::use_aggregator_source_data();
309 492 endif;
310 493
311 - if ($original) : $vals = get_post_custom_values('syndication_source_id_original');
494 + if ($original) : $vals = get_post_custom_values('syndication_source_id_original', $id);
312 495 else : $vals = array();
313 496 endif;
314 497
315 - if (count($vals) == 0) : $vals = array(get_feed_meta('feed/id'));
498 + if (count($vals) == 0) : $vals = array(get_feed_meta('feed/id', $id));
316 499 endif;
317 500
318 501 if (count($vals) > 0) : $ret = $vals[0]; else : $ret = NULL; endif;
319 502
@@ -319,50 +502,104 @@
319 502
320 503 return $ret;
321 504 } /* function get_syndication_feed_guid () */
322 505
323 -function the_syndication_feed_guid ($original = NULL) { echo get_syndication_feed_guid($original); }
506 +function the_syndication_feed_guid ($original = NULL, $id = NULL) { echo get_syndication_feed_guid($original, $id); }
324 507
325 -function get_syndication_feed_id () { list($u) = get_post_custom_values('syndication_feed_id'); return $u; }
326 -function the_syndication_feed_id () { echo get_syndication_feed_id(); }
508 +function get_syndication_feed_id ($id = NULL) { list($u) = get_post_custom_values('syndication_feed_id', $id); return $u; }
509 +function the_syndication_feed_id ($id = NULL) { echo get_syndication_feed_id($id); }
327 510
328 511 $feedwordpress_linkcache = array (); // only load links from database once
512 +function get_syndication_feed_object ($id = NULL) {
513 + global $feedwordpress_linkcache;
329 514
330 -function get_feed_meta ($key) {
331 - global $wpdb, $feedwordpress_linkcache;
332 - $feed_id = get_syndication_feed_id();
515 + $link = NULL;
333 516
334 - $ret = NULL;
517 + $feed_id = get_syndication_feed_id($id);
335 518 if (strlen($feed_id) > 0):
336 519 if (isset($feedwordpress_linkcache[$feed_id])) :
337 520 $link = $feedwordpress_linkcache[$feed_id];
338 521 else :
339 - $link =& new SyndicatedLink($feed_id);
522 + $link = new SyndicatedLink($feed_id);
340 523 $feedwordpress_linkcache[$feed_id] = $link;
341 524 endif;
525 + endif;
526 + return $link;
527 +}
342 528
529 +function get_feed_meta ($key, $id = NULL) {
530 + $ret = NULL;
531 +
532 + $link = get_syndication_feed_object($id);
533 + if (is_object($link) and isset($link->settings[$key])) :
343 534 $ret = $link->settings[$key];
344 535 endif;
345 536 return $ret;
346 537 } /* get_feed_meta() */
347 538
348 -function get_syndication_permalink () {
349 - list($u) = get_post_custom_values('syndication_permalink'); return $u;
539 +function get_syndication_permalink ($id = NULL) {
540 + list($u) = get_post_custom_values('syndication_permalink', $id); return $u;
350 541 }
351 -function the_syndication_permalink () {
352 - echo get_syndication_permalink();
542 +function the_syndication_permalink ($id = NULL) {
543 + echo get_syndication_permalink($id);
353 544 }
354 545
546 +/**
547 + * get_local_permalink: returns a string containing the internal permalink
548 + * for a post (whether syndicated or not) on your local WordPress installation.
549 + * This may be useful if you want permalinks to point to the original source of
550 + * an article for most purposes, but want to retrieve a URL for the local
551 + * representation of the post for one or two limited purposes (for example,
552 + * linking to a comments page on your local aggregator site).
553 + *
554 + * @param $id The numerical ID of the post to get the permalink for. If empty,
555 + * defaults to the current post in a Loop context.
556 + * @return string The URL of the local permalink for this post.
557 + *
558 + * @uses get_permalink()
559 + * @global $feedwordpress_the_original_permalink
560 + *
561 + * @since 2010.0217
562 + */
563 +function get_local_permalink ($id = NULL) {
564 + global $feedwordpress_the_original_permalink;
565 +
566 + // get permalink, and thus activate filter and force global to be filled
567 + // with original URL.
568 + $url = get_permalink($id);
569 + return $feedwordpress_the_original_permalink;
570 +} /* get_local_permalink() */
571 +
572 +/**
573 + * the_original_permalink: displays the contents of get_original_permalink()
574 + *
575 + * @param $id The numerical ID of the post to get the permalink for. If empty,
576 + * defaults to the current post in a Loop context.
577 + *
578 + * @uses get_local_permalinks()
579 + * @uses apply_filters
580 + *
581 + * @since 2010.0217
582 + */
583 +function the_local_permalink ($id = NULL) {
584 + print apply_filters('the_permalink', get_local_permalink($id));
585 +} /* function the_local_permalink() */
586 +
355 587 ################################################################################
356 588 ## FILTERS: syndication-aware handling of post data for templates and feeds ####
357 589 ################################################################################
358 590
359 591 $feedwordpress_the_syndicated_content = NULL;
592 +$feedwordpress_the_original_permalink = NULL;
360 593
361 594 function feedwordpress_preserve_syndicated_content ($text) {
362 595 global $feedwordpress_the_syndicated_content;
363 596
364 - if ( is_syndicated() and get_option('feedwordpress_formatting_filters') != 'yes' ) :
597 + $globalExpose = (get_option('feedwordpress_formatting_filters') == 'yes');
598 + $localExpose = get_post_custom_values('_feedwordpress_formatting_filters');
599 + $expose = ($globalExpose or ((count($localExpose) > 0) and $localExpose[0]));
600 +
601 + if ( is_syndicated() and !$expose ) :
365 602 $feedwordpress_the_syndicated_content = $text;
366 603 else :
367 604 $feedwordpress_the_syndicated_content = NULL;
368 605 endif;
@@ -383,16 +620,16 @@
383 620 // In a post context....
384 621 if (is_syndicated()) :
385 622 ?>
386 623 <source>
387 - <title><?php the_syndication_source(); ?></title>
388 - <link rel="alternate" type="text/html" href="<?php the_syndication_source_link(); ?>" />
389 - <link rel="self" href="<?php the_syndication_feed(); ?>" />
624 + <title><?php print htmlspecialchars(get_syndication_source()); ?></title>
625 + <link rel="alternate" type="text/html" href="<?php print htmlspecialchars(get_syndication_source_link()); ?>" />
626 + <link rel="self" href="<?php print htmlspecialchars(get_syndication_feed()); ?>" />
390 627 <?php
391 628 $id = get_syndication_feed_guid();
392 629 if (strlen($id) > 0) :
393 630 ?>
394 - <id><?php print $id; ?></id>
631 + <id><?php print htmlspecialchars($id); ?></id>
395 632 <?php
396 633 endif;
397 634 $updated = get_feed_meta('feed/updated');
398 635 if (strlen($updated) > 0) : ?>
@@ -404,17 +641,131 @@
404 641 <?php
405 642 endif;
406 643 }
407 644
645 +/**
646 + * syndication_permalink: Allow WordPress to use the original remote URL of
647 + * syndicated posts as their permalink. Can be turned on or off by by setting in
648 + * Syndication => Posts & Links. Saves the old internal permalink in a global
649 + * variable for later use.
650 + *
651 + * @param string $permalink The internal permalink
652 + * @return string The new permalink. Same as the old if the post is not
653 + * syndicated, or if FWP is set to use internal permalinks, or if the post
654 + * was syndicated, but didn't have a proper permalink recorded.
655 + *
656 + * @uses FeedWordPress::munge_permalinks()
657 + * @uses get_syndication_permalink()
658 + * @global $feedwordpress_the_original_permalink
659 + */
408 660 function syndication_permalink ($permalink = '') {
409 - if (get_option('feedwordpress_munge_permalink') != 'no'):
410 - $uri = get_syndication_permalink();
411 - return ((strlen($uri) > 0) ? $uri : $permalink);
412 - else:
413 - return $permalink;
661 + global $feedwordpress_the_original_permalink;
662 +
663 + // Save the local permalink in case we need to retrieve it later.
664 + $feedwordpress_the_original_permalink = $permalink;
665 +
666 + // Map this permalink to a post ID so we can get the correct permalink
667 + // even outside of the Post Loop. Props Björn.
668 + $id = url_to_postid($permalink);
669 +
670 + $munge = false;
671 + $link = get_syndication_feed_object($id);
672 + if (is_object($link)) :
673 + $munge = ($link->setting('munge permalink', 'munge_permalink', 'yes') != 'no');
414 674 endif;
415 -} // function syndication_permalink ()
416 675
676 + if ($munge):
677 + $uri = get_syndication_permalink($id);
678 + $permalink = ((strlen($uri) > 0) ? $uri : $permalink);
679 + endif;
680 + return $permalink;
681 +} /* function syndication_permalink () */
682 +
683 +/**
684 + * syndication_permalink_escaped: Escape XML special characters in syndicated
685 + * permalinks when used in feed contexts and HTML display contexts.
686 + *
687 + * @param string $permalink
688 + * @return string
689 + *
690 + * @uses is_syndicated()
691 + * @uses FeedWordPress::munge_permalinks()
692 + *
693 + */
694 +function syndication_permalink_escaped ($permalink) {
695 + if (is_syndicated() and FeedWordPress::munge_permalinks()) :
696 + // This is a foreign link; WordPress can't vouch for its not
697 + // having any entities that need to be &-escaped. So we'll do
698 + // it here.
699 + $permalink = esc_html($permalink);
700 + endif;
701 + return $permalink;
702 +} /* function syndication_permalink_escaped() */
703 +
704 +/**
705 + * syndication_comments_feed_link: Escape XML special characters in comments
706 + * feed links
707 + *
708 + * @param string $link
709 + * @return string
710 + *
711 + * @uses is_syndicated()
712 + * @uses FeedWordPress::munge_permalinks()
713 + */
714 +function syndication_comments_feed_link ($link) {
715 + global $feedwordpress_the_original_permalink, $id;
716 +
717 + if (is_syndicated() and FeedWordPress::munge_permalinks()) :
718 + // If the source post provided a comment feed URL using
719 + // wfw:commentRss or atom:link/@rel="replies" we can make use of
720 + // that value here.
721 + $source = get_syndication_feed_object();
722 + $replacement = NULL;
723 + if ($source->setting('munge comments feed links', 'munge_comments_feed_links', 'yes') != 'no') :
724 + $commentFeeds = get_post_custom_values('wfw:commentRSS');
725 + if (
726 + is_array($commentFeeds)
727 + and (count($commentFeeds) > 0)
728 + and (strlen($commentFeeds[0]) > 0)
729 + ) :
730 + $replacement = $commentFeeds[0];
731 +
732 + // This is a foreign link; WordPress can't vouch for its not
733 + // having any entities that need to be &-escaped. So we'll do it
734 + // here.
735 + $replacement = esc_html($replacement);
736 + endif;
737 + endif;
738 +
739 + if (is_null($replacement)) :
740 + // Q: How can we get the proper feed format, since the
741 + // format is, stupidly, not passed to the filter?
742 + // A: Kludge kludge kludge kludge!
743 + $fancy_permalinks = ('' != get_option('permalink_structure'));
744 + if ($fancy_permalinks) :
745 + preg_match('|/feed(/([^/]+))?/?$|', $link, $ref);
746 +
747 + $format = (isset($ref[2]) ? $ref[2] : '');
748 + if (strlen($format) == 0) : $format = get_default_feed(); endif;
749 +
750 + $replacement = trailingslashit($feedwordpress_the_original_permalink) . 'feed';
751 + if ($format != get_default_feed()) :
752 + $replacement .= '/'.$format;
753 + endif;
754 + $replacement = user_trailingslashit($replacement, 'single_feed');
755 + else :
756 + // No fancy permalinks = no problem
757 + // WordPress doesn't call get_permalink() to
758 + // generate the comment feed URL, so the
759 + // comments feed link is never munged by FWP.
760 + endif;
761 + endif;
762 +
763 + if (!is_null($replacement)) : $link = $replacement; endif;
764 + endif;
765 + return $link;
766 +} /* function syndication_comments_feed_link() */
767 +
417 768 ################################################################################
418 769 ## ADMIN MENU ADD-ONS: register Dashboard management pages #####################
419 770 ################################################################################
420 771
@@ -421,14 +772,45 @@
421 772 function fwp_add_pages () {
422 773 global $fwp_capability;
423 774 global $fwp_path;
424 775
425 - add_menu_page('Syndicated Sites', 'Syndication', $fwp_capability['manage_links'], $fwp_path.'/syndication.php');
426 - add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Authors', 'Authors', $fwp_capability['manage_options'], $fwp_path.'/authors.php');
427 - add_submenu_page($fwp_path.'/syndication.php', 'Syndication Options', 'Options', $fwp_capability['manage_options'], $fwp_path.'/syndication-options.php');
428 - add_options_page('Syndication Options', 'Syndication', $fwp_capability['manage_options'], $fwp_path.'/syndication-options.php');
429 -} // function fwp_add_pages () */
776 + $menu = array('Syndicated Sites', 'Syndication', $fwp_capability['manage_links'], $fwp_path.'/syndication.php', NULL);
777 + if (fwp_test_wp_version(FWP_SCHEMA_27)) :
778 + // add icon parameter
779 + $menu[] = WP_PLUGIN_URL.'/'.$fwp_path.'/feedwordpress-tiny.png';
780 + endif;
430 781
782 + call_user_func_array('add_menu_page', $menu);
783 + add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Feeds & Updates', 'Feeds & Updates', $fwp_capability['manage_options'], $fwp_path.'/feeds-page.php');
784 + add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Posts & Links', 'Posts & Links', $fwp_capability['manage_options'], $fwp_path.'/posts-page.php');
785 + add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Authors', 'Authors', $fwp_capability['manage_options'], $fwp_path.'/authors-page.php');
786 + add_submenu_page($fwp_path.'/syndication.php', 'Categories'.FEEDWORDPRESS_AND_TAGS, 'Categories'.FEEDWORDPRESS_AND_TAGS, $fwp_capability['manage_options'], $fwp_path.'/categories-page.php');
787 + add_submenu_page($fwp_path.'/syndication.php', 'FeedWordPress Performance', 'Performance', $fwp_capability['manage_options'], $fwp_path.'/performance-page.php');
788 + add_submenu_page($fwp_path.'/syndication.php', 'FeedWordPress Diagnostics', 'Diagnostics', $fwp_capability['manage_options'], $fwp_path.'/diagnostics-page.php');
789 +} /* function fwp_add_pages () */
790 +
791 +function fwp_check_debug () {
792 + // This is a horrible fucking kludge that I have to do because the
793 + // admin notice code is triggered before the code that updates the
794 + // setting.
795 + if (isset($_POST['feedwordpress_debug'])) :
796 + $feedwordpress_debug = $_POST['feedwordpress_debug'];
797 + else :
798 + $feedwordpress_debug = get_option('feedwordpress_debug');
799 + endif;
800 + if ($feedwordpress_debug==='yes') :
801 +?>
802 + <div class="error">
803 +<p><strong>FeedWordPress warning.</strong> Debugging mode is <strong>ON</strong>.
804 +While it remains on, FeedWordPress displays many diagnostic error messages,
805 +warnings, and notices that are ordinarily suppressed, and also turns off all
806 +caching of feeds. Use with caution: this setting is absolutely inappropriate
807 +for a production server.</p>
808 + </div>
809 +<?php
810 + endif;
811 +} /* function fwp_check_debug () */
812 +
431 813 ################################################################################
432 814 ## fwp_hold_pings() and fwp_release_pings(): Outbound XML-RPC ping reform ####
433 815 ## ... 'coz it's rude to send 500 pings the first time your aggregator runs ####
434 816 ################################################################################
@@ -484,8 +866,67 @@
484 866 endif;
485 867 endif;
486 868 }
487 869
870 + function feedwordpress_add_post_edit_controls () {
871 + add_meta_box('feedwordpress-post-controls', __('Syndication'), 'feedwordpress_post_edit_controls', 'post', 'side', 'high');
872 + } // function FeedWordPress::postEditControls
873 +
874 + function feedwordpress_post_edit_controls () {
875 + global $post;
876 +
877 + $frozen_values = get_post_custom_values('_syndication_freeze_updates', $post->ID);
878 + $frozen_post = (count($frozen_values) > 0 and 'yes' == $frozen_values[0]);
879 +
880 + if (is_syndicated($post->ID)) :
881 + ?>
882 + <p>This is a syndicated post, which originally appeared at
883 + <cite><?php print esc_html(get_syndication_source(NULL, $post->ID)); ?></cite>.
884 + <a href="<?php print esc_html(get_syndication_permalink($post->ID)); ?>">View original post</a>.</p>
885 +
886 + <p><input type="hidden" name="feedwordpress_noncename" id="feedwordpress_noncename" value="<?php print wp_create_nonce(plugin_basename(__FILE__)); ?>" />
887 + <label><input type="checkbox" name="freeze_updates" value="yes" <?php if ($frozen_post) : ?>checked="checked"<?php endif; ?> /> <strong>Manual editing.</strong>
888 + If set, FeedWordPress will not overwrite the changes you make manually
889 + to this post, if the syndicated content is updated on the
890 + feed.</label></p>
891 + <?php
892 + else :
893 + ?>
894 + <p>This post was created locally at this website.</p>
895 + <?php
896 + endif;
897 + } // function feedwordpress_post_edit_controls () */
898 +
899 + function feedwordpress_save_post_edit_controls ( $post_id ) {
900 + global $post;
901 +
902 + if (!isset($_POST['feedwordpress_noncename']) or !wp_verify_nonce($_POST['feedwordpress_noncename'], plugin_basename(__FILE__))) :
903 + return $post_id;
904 + endif;
905 +
906 + // Verify if this is an auto save routine. If it is our form has
907 + // not been submitted, so we don't want to do anything.
908 + if ( defined('DOING_AUTOSAVE') and DOING_AUTOSAVE ) :
909 + return $post_id;
910 + endif;
911 +
912 + // Check permissions
913 + if ( !current_user_can( 'edit_'.$_POST['post_type'], $post_id) ) :
914 + return $post_id;
915 + endif;
916 +
917 + // OK, we're golden. Now let's save some data.
918 + if (isset($_POST['freeze_updates'])) :
919 + update_post_meta($post_id, '_syndication_freeze_updates', $_POST['freeze_updates']);
920 + $ret = $_POST['freeze_updates'];
921 + else :
922 + delete_post_meta($post_id, '_syndication_freeze_updates');
923 + $ret = NULL;
924 + endif;
925 +
926 + return $ret;
927 + } // function feedwordpress_save_edit_controls
928 +
488 929 ################################################################################
489 930 ## class FeedWordPress #########################################################
490 931 ################################################################################
491 932
@@ -529,9 +970,9 @@
529 970 function FeedWordPress () {
530 971 $this->feeds = array ();
531 972 $links = FeedWordPress::syndicated_links();
532 973 if ($links): foreach ($links as $link):
533 - $this->feeds[] =& new SyndicatedLink($link);
974 + $this->feeds[] = new SyndicatedLink($link);
534 975 endforeach; endif;
535 976 } // FeedWordPress::FeedWordPress ()
536 977
537 978 # function update (): polls for updates on one or more Contributor feeds
@@ -617,9 +1058,9 @@
617 1058 if (!is_null($crash_ts) and (time() > $crash_ts)) : // Check whether we've exceeded the time limit
618 1059 break;
619 1060 endif;
620 1061
621 - $pinged_that = (is_null($uri) or in_array($uri, array($feed->uri(), $feed->homepage())));
1062 + $pinged_that = (is_null($uri) or ($uri=='*') or in_array($uri, array($feed->uri(), $feed->homepage())));
622 1063
623 1064 if (!is_null($uri)) : // A site-specific ping always updates
624 1065 $timely = true;
625 1066 else :
@@ -635,10 +1076,12 @@
635 1076 $start_ts = time();
636 1077 $added = $feed->poll($crash_ts);
637 1078 do_action('feedwordpress_check_feed_complete', $feed->settings, $added, time() - $start_ts);
638 1079
639 - if (isset($added['new'])) : $delta['new'] += $added['new']; endif;
640 - if (isset($added['updated'])) : $delta['updated'] += $added['updated']; endif;
1080 + if (is_array($added)) : // Success
1081 + if (isset($added['new'])) : $delta['new'] += $added['new']; endif;
1082 + if (isset($added['updated'])) : $delta['updated'] += $added['updated']; endif;
1083 + endif;
641 1084 endif;
642 1085 endforeach;
643 1086
644 1087 do_action('feedwordpress_update_complete', $delta);
@@ -647,8 +1090,11 @@
647 1090 }
648 1091
649 1092 function stale () {
650 1093 if (get_option('feedwordpress_automatic_updates')) :
1094 + // Do our best to avoid possible simultaneous
1095 + // updates by getting up-to-the-minute settings.
1096 +
651 1097 $last = get_option('feedwordpress_last_update_all');
652 1098
653 1099 // If we haven't updated all yet, give it a time window
654 1100 if (false === $last) :
@@ -667,12 +1113,8 @@
667 1113 else :
668 1114 FeedWordPress::critical_bug('FeedWordPress::stale::last', $last, __LINE__);
669 1115 endif;
670 1116
671 - // Explicit request for an update (e.g. from a cron job).
672 - elseif (FeedWordPress::update_requested()) :
673 - $ret = true;
674 -
675 1117 else :
676 1118 $ret = false;
677 1119 endif;
678 1120 return $ret;
@@ -678,11 +1120,25 @@
678 1120 return $ret;
679 1121 } // FeedWordPress::stale()
680 1122
681 1123 function update_requested () {
682 - return (isset($_REQUEST['update_feedwordpress']) and $_REQUEST['update_feedwordpress']);
1124 + return (
1125 + isset($_REQUEST['update_feedwordpress'])
1126 + and $_REQUEST['update_feedwordpress']
1127 + );
683 1128 } // FeedWordPress::update_requested()
684 1129
1130 + function update_requested_url () {
1131 + $ret = null;
1132 +
1133 + if (($_REQUEST['update_feedwordpress']=='*')
1134 + or (preg_match('|^http://.*|i', $_REQUEST['update_feedwordpress']))) :
1135 + $ret = $_REQUEST['update_feedwordpress'];
1136 + endif;
1137 +
1138 + return $ret;
1139 + } // FeedWordPress::update_requested_url()
1140 +
685 1141 function syndicate_link ($name, $uri, $rss) {
686 1142 global $wpdb;
687 1143
688 1144 // Get the category ID#
@@ -690,16 +1146,29 @@
690 1146
691 1147 // WordPress gets cranky if there's no homepage URI
692 1148 if (!isset($uri) or strlen($uri)<1) : $uri = $rss; endif;
693 1149
694 - if (function_exists('wp_insert_link')) { // WordPress 2.x
1150 + if (function_exists('wp_insert_link')) : // WordPress 2.x
1151 + if (FeedWordPressCompatibility::test_version(0, FWP_SCHEMA_21)) :
1152 + // Morons.
1153 + $name = $wpdb->escape($name);
1154 + $uri = $wpdb->escape($uri);
1155 + $rss = $wpdb->escape($rss);
1156 +
1157 + // Comes in as a single category
1158 + $linkCats = $cat_id;
1159 + else :
1160 + // Comes in as an array of categories
1161 + $linkCats = array($cat_id);
1162 + endif;
1163 +
695 1164 $link_id = wp_insert_link(array(
696 1165 "link_name" => $name,
697 1166 "link_url" => $uri,
698 - "link_category" => array($cat_id),
1167 + "link_category" => $linkCats,
699 1168 "link_rss" => $rss
700 1169 ));
701 - } else { // WordPress 1.5.x
1170 + else : // WordPress 1.5.x
702 1171 $result = $wpdb->query("
703 1172 INSERT INTO $wpdb->links
704 1173 SET
705 1174 link_name = '".$wpdb->escape($name)."',
@@ -707,12 +1176,20 @@
707 1176 link_category = '".$wpdb->escape($cat_id)."',
708 1177 link_rss = '".$wpdb->escape($rss)."'
709 1178 ");
710 1179 $link_id = $wpdb->insert_id;
711 - } // if
1180 + endif;
712 1181 return $link_id;
713 1182 } // function FeedWordPress::syndicate_link()
714 1183
1184 + /*static*/ function syndicated_status ($what, $default) {
1185 + $ret = get_option("feedwordpress_syndicated_{$what}_status");
1186 + if (!$ret) :
1187 + $ret = $default;
1188 + endif;
1189 + return $ret;
1190 + } /* FeedWordPress::syndicated_status() */
1191 +
715 1192 function on_unfamiliar ($what = 'author', $override = NULL) {
716 1193 $set = array(
717 1194 'author' => array('create', 'default', 'filter'),
718 1195 'category' => array('create', 'tag', 'default', 'filter'),
@@ -719,8 +1196,10 @@
719 1196 );
720 1197
721 1198 if (is_string($override)) :
722 1199 $ret = strtolower($override);
1200 + else :
1201 + $ret = NULL;
723 1202 endif;
724 1203
725 1204 if (!is_numeric($override) and !in_array($ret, $set[$what])) :
726 1205 $ret = get_option('feedwordpress_unfamiliar_'.$what);
@@ -756,8 +1235,19 @@
756 1235 $ret = get_option('feedwordpress_use_aggregator_source_data');
757 1236 return apply_filters('syndicated_post_use_aggregator_source_data', ($ret=='yes'));
758 1237 }
759 1238
1239 + /**
1240 + * FeedWordPress::munge_permalinks: check whether or not FeedWordPress
1241 + * should rewrite permalinks for syndicated items to reflect their
1242 + * original location.
1243 + *
1244 + * @return bool TRUE if FeedWordPress SHOULD rewrite permalinks; FALSE otherwise
1245 + */
1246 + /*static*/ function munge_permalinks () {
1247 + return (get_option('feedwordpress_munge_permalink', /*default=*/ 'yes') != 'no');
1248 + } /* FeedWordPress::munge_permalinks() */
1249 +
760 1250 function syndicated_links () {
761 1251 $contributors = FeedWordPress::link_category_id();
762 1252 if (function_exists('get_bookmarks')) :
763 1253 $links = get_bookmarks(array("category" => $contributors));
@@ -771,61 +1261,31 @@
771 1261 global $wpdb, $wp_db_version;
772 1262
773 1263 $cat_id = get_option('feedwordpress_cat_id');
774 1264
775 - // If we don't yet *have* the category, we'll have to create it
776 - if ($cat_id === false) :
777 - $cat = $wpdb->escape(DEFAULT_SYNDICATION_CATEGORY);
778 -
779 - // Look for something with the right name...
780 - // -----------------------------------------
1265 + // If we don't yet have the category ID stored, search by name
1266 + if (!$cat_id) :
1267 + $cat_id = FeedWordPressCompatibility::link_category_id(DEFAULT_SYNDICATION_CATEGORY);
781 1268
782 - // WordPress 2.3 introduces a new taxonomy/term API
783 - if (function_exists('is_term')) :
784 - $cat_id = is_term($cat, 'link_category');
785 - // WordPress 2.1 and 2.2 use a common table for both link and post categories
786 - elseif (isset($wp_db_version) and ($wp_db_version >= FWP_SCHEMA_21 and $wp_db_version < FWP_SCHEMA_23) ) :
787 - $cat_id = $wpdb->get_var("SELECT cat_id FROM {$wpdb->categories} WHERE cat_name='$cat'");
788 - // WordPress 1.5 and 2.0.x have a separate table for link categories
789 - elseif (!isset($wp_db_version) or $wp_db_version < FWP_SCHEMA_21) :
790 - $cat_id = $wpdb->get_var("SELECT cat_id FROM {$wpdb->linkcategories} WHERE cat_name='$cat'");
791 - // This should never happen.
792 - else :
793 - FeedWordPress::critical_bug('FeedWordPress::link_category_id::wp_db_version', $wp_db_version, __LINE__);
1269 + if ($cat_id) :
1270 + // We found it; let's stamp it.
1271 + update_option('feedwordpress_cat_id', $cat_id);
794 1272 endif;
795 1273
796 - // If you still can't find anything, make it for yourself.
797 - // -------------------------------------------------------
798 - if (!$cat_id) :
799 - // WordPress 2.3+ term/taxonomy API
800 - if (function_exists('wp_insert_term')) :
801 - $term = wp_insert_term($cat, 'link_category');
802 - $cat_id = $term['term_id'];
803 - // WordPress 2.1, 2.2 category API. By the way, why the fuck is this API function only available in a wp-admin module?
804 - elseif (function_exists('wp_insert_category')) :
805 - $cat_id = wp_insert_category(array('cat_name' => $cat));
806 - // WordPress 1.5 and 2.0.x
807 - elseif (!isset($wp_db_version) or $wp_db_version < FWP_SCHEMA_21) :
808 - $result = $wpdb->query("
809 - INSERT INTO $wpdb->linkcategories
810 - SET
811 - cat_id = 0,
812 - cat_name='$cat',
813 - show_images='N',
814 - show_description='N',
815 - show_rating='N',
816 - show_updated='N',
817 - sort_order='name'
818 - ");
819 - $cat_id = $wpdb->insert_id;
820 - // This should never happen.
821 - else :
822 - FeedWordPress::critical_bug('FeedWordPress::link_category_id::wp_db_version', $wp_db_version, __LINE__);
823 - endif;
824 - endif;
1274 + // If we *do* have the category ID stored, verify that it exists
1275 + else :
1276 + $cat_id = FeedWordPressCompatibility::link_category_id((int) $cat_id, 'cat_id');
1277 + endif;
1278 +
1279 + // If we could not find an appropriate link category,
1280 + // make a new one for ourselves.
1281 + if (!$cat_id) :
1282 + $cat_id = FeedWordPressCompatibility::insert_link_category(DEFAULT_SYNDICATION_CATEGORY);
825 1283
1284 + // Stamp it
826 1285 update_option('feedwordpress_cat_id', $cat_id);
827 1286 endif;
1287 +
828 1288 return $cat_id;
829 1289 } // function FeedWordPress::link_category_id()
830 1290
831 1291 # Upgrades and maintenance...
@@ -835,12 +1295,9 @@
835 1295 $ret = false; // innocent until proven guilty
836 1296 if (!$fwp_db_version or $fwp_db_version < FEEDWORDPRESS_VERSION) :
837 1297 // This is an older version or a fresh install. Does it
838 1298 // require a database upgrade or database initialization?
839 - if ($fwp_db_version > 0.96) :
840 - // No. Just brand it with the new version.
841 - update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
842 - else :
1299 + if ($fwp_db_version <= 0.96) :
843 1300 // Yes. Check to see whether this is a fresh install or an upgrade.
844 1301 $syn = $wpdb->get_col("
845 1302 SELECT post_id
846 1303 FROM $wpdb->postmeta
@@ -850,8 +1307,21 @@
850 1307 $ret = true;
851 1308 else : // fresh install; brand it as ours
852 1309 update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
853 1310 endif;
1311 + elseif ($fwp_db_version < 2009.0707) :
1312 + // We need to clear out any busted AJAX crap
1313 + if (fwp_test_wp_version(FWP_SCHEMA_HAS_USERMETA)) :
1314 + $wpdb->query("
1315 + DELETE FROM $wpdb->usermeta
1316 + WHERE LOCATE('feedwordpress', meta_key)
1317 + AND LOCATE('box', meta_key);
1318 + ");
1319 + endif;
1320 + update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1321 + else :
1322 + // No. Just brand it with the new version.
1323 + update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
854 1324 endif;
855 1325 endif;
856 1326 return $ret;
857 1327 }
@@ -861,56 +1331,14 @@
861 1331
862 1332 if (is_null($from) or $from <= 0.96) : $from = 0.96; endif;
863 1333
864 1334 switch ($from) :
865 - case 0.96: // account for changes to syndication custom values and guid
866 - echo "<p>Upgrading database from {$from} to ".FEEDWORDPRESS_VERSION."...</p>\n";
1335 + case 0.96:
1336 + // Dropping legacy upgrade code. If anyone is still
1337 + // using 0.96 and just now decided to upgrade, well, I'm
1338 + // sorry about that. You'll just have to cope with a few
1339 + // duplicate posts.
867 1340
868 - $cat_id = FeedWordPress::link_category_id();
869 -
870 - // Avoid duplicates
871 - $wpdb->query("DELETE FROM `{$wpdb->postmeta}` WHERE meta_key = 'syndication_feed_id'");
872 -
873 - // Look up all the link IDs
874 - $wpdb->query("
875 - CREATE TEMPORARY TABLE tmp_custom_values
876 - SELECT
877 - NULL AS meta_id,
878 - post_id,
879 - 'syndication_feed_id' AS meta_key,
880 - link_id AS meta_value
881 - FROM `{$wpdb->postmeta}`, `{$wpdb->links}`
882 - WHERE
883 - meta_key='syndication_feed'
884 - AND meta_value=link_rss
885 - AND link_category = {$cat_id}
886 - ");
887 -
888 - // Now attach them to their posts
889 - $wpdb->query("INSERT INTO `{$wpdb->postmeta}` SELECT * FROM tmp_custom_values");
890 -
891 - // And clean up after ourselves.
892 - $wpdb->query("DROP TABLE tmp_custom_values");
893 -
894 - // Now fix the guids to avoid duplicate posts
895 - echo "<ul>";
896 - foreach ($this->feeds as $feed) :
897 - echo "<li>Fixing post meta-data for <cite>".$feed['link/name']."</cite> &#8230; "; flush();
898 - $rss = @fetch_rss($feed['link/uri']);
899 - if (is_array($rss->items)) :
900 - foreach ($rss->items as $item) :
901 - $guid = $wpdb->escape(FeedWordPress::guid($item, $feed)); // new GUID algorithm
902 - $link = $wpdb->escape($item['link']);
903 -
904 - $wpdb->query("
905 - UPDATE `{$wpdb->posts}` SET guid='{$guid}' WHERE guid='{$link}'
906 - ");
907 - endforeach;
908 - endif;
909 - echo "<strong>complete.</strong></li>\n";
910 - endforeach;
911 - echo "</ul>\n";
912 -
913 1341 // Mark the upgrade as successful.
914 1342 update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
915 1343 endswitch;
916 1344 echo "<p>Upgrade complete. FeedWordPress is now ready to use again.</p>";
@@ -915,8 +1343,27 @@
915 1343 endswitch;
916 1344 echo "<p>Upgrade complete. FeedWordPress is now ready to use again.</p>";
917 1345 } /* FeedWordPress::upgrade_database() */
918 1346
1347 + function has_guid_index () {
1348 + global $wpdb;
1349 +
1350 + $found = false; // Guilty until proven innocent.
1351 +
1352 + $results = $wpdb->get_results("
1353 + SHOW INDEXES FROM {$wpdb->posts}
1354 + ");
1355 + if ($results) :
1356 + foreach ($results as $index) :
1357 + if (isset($index->Column_name)
1358 + and ('guid' == $index->Column_name)) :
1359 + $found = true;
1360 + endif;
1361 + endforeach;
1362 + endif;
1363 + return $found;
1364 + } /* FeedWordPress::has_guid_index () */
1365 +
919 1366 function create_guid_index () {
920 1367 global $wpdb;
921 1368
922 1369 $wpdb->query("
@@ -923,8 +1370,72 @@
923 1370 CREATE INDEX {$wpdb->posts}_guid_idx ON {$wpdb->posts}(guid)
924 1371 ");
925 1372 } /* FeedWordPress::create_guid_index () */
926 1373
1374 + function remove_guid_index () {
1375 + global $wpdb;
1376 +
1377 + $wpdb->query("
1378 + DROP INDEX {$wpdb->posts}_guid_idx ON {$wpdb->posts}
1379 + ");
1380 + }
1381 +
1382 + /*static*/ function fetch ($url) {
1383 + $feed = new SimplePie();
1384 + $feed->set_feed_url($url);
1385 + $feed->set_cache_class('WP_Feed_Cache');
1386 + $feed->set_file_class('WP_SimplePie_File');
1387 + $feed->set_content_type_sniffer_class('FeedWordPress_Content_Type_Sniffer');
1388 + $feed->set_cache_duration(FeedWordPress::cache_duration());
1389 + $feed->init();
1390 + $feed->handle_content_type();
1391 +
1392 + if ($feed->error()) :
1393 + $ret = new WP_Error('simplepie-error', $feed->error());
1394 + else :
1395 + $ret = $feed;
1396 + endif;
1397 + return $ret;
1398 + } /* FeedWordPress::fetch () */
1399 +
1400 + function clear_cache () {
1401 + global $wpdb;
1402 +
1403 + // The WordPress SimplePie module stores its cached feeds as
1404 + // transient records in the options table. The data itself is
1405 + // stored in `_transient_feed_{md5 of url}` and the last-modified
1406 + // timestamp in `_transient_feed_mod_{md5 of url}`. Timeouts for
1407 + // these records are stored in `_transient_timeout_feed_{md5}`.
1408 + // Since the md5 is always 32 characters in length, the
1409 + // option_name is always over 32 characters.
1410 + $ret = $wpdb->query("
1411 + DELETE FROM {$wpdb->options}
1412 + WHERE option_name LIKE '_transient%_feed_%' AND LENGTH(option_name) > 32
1413 + ");
1414 + return (int) ($ret / 4); // Each transient has 4 rows: the data, the modified timestamp; and the timeouts for each
1415 + } /* FeedWordPress::clear_cache () */
1416 +
1417 + function cache_duration () {
1418 + $duration = NULL;
1419 + if (defined('FEEDWORDPRESS_CACHE_AGE')) :
1420 + $duration = FEEDWORDPRESS_CACHE_AGE;
1421 + endif;
1422 + return $duration;
1423 + }
1424 + function cache_lifetime ($duration) {
1425 + // Check for explicit setting of a lifetime duration
1426 + if (defined('FEEDWORDPRESS_CACHE_LIFETIME')) :
1427 + $duration = FEEDWORDPRESS_CACHE_LIFETIME;
1428 +
1429 + // Fall back to the cache freshness duration
1430 + elseif (defined('FEEDWORDPRESS_CACHE_AGE')) :
1431 + $duration = FEEDWORDPRESS_CACHE_AGE;
1432 + endif;
1433 +
1434 + // Fall back to WordPress default
1435 + return $duration;
1436 + } /* FeedWordPress::cache_lifetime () */
1437 +
927 1438 # Utility functions for handling text settings
928 1439 function negative ($f, $setting) {
929 1440 $nego = array ('n', 'no', 'f', 'false');
930 1441 return (isset($f[$setting]) and in_array(strtolower($f[$setting]), $nego));
@@ -943,1518 +1454,70 @@
943 1454 echo '<p>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>';
944 1455 echo "\n<plaintext>";
945 1456 echo "Triggered at line # ".$line."\n";
946 1457 echo "FeedWordPress version: ".FEEDWORDPRESS_VERSION."\n";
947 - echo "WordPress version: $wp_version\n";
1458 + echo "WordPress version: {$wp_version}\n";
948 1459 echo "PHP version: ".phpversion()."\n";
949 1460 echo "\n";
950 1461 echo $varname.": "; var_dump($var); echo "\n";
951 1462 die;
952 1463 }
953 -} // class FeedWordPress
954 -
955 -class SyndicatedPost {
956 - var $item = null;
957 1464
958 - var $link = null;
959 - var $feed = null;
960 - var $feedmeta = null;
961 -
962 - var $post = array ();
963 - var $_base = null;
964 -
965 - var $_freshness = null;
966 - var $_wp_id = null;
967 -
968 - function SyndicatedPost ($item, $link) {
969 - global $wpdb;
970 -
971 - $this->link = $link;
972 - $feedmeta = $link->settings;
973 - $feed = $link->magpie;
974 -
975 - # This is ugly as all hell. I'd like to use apply_filters()'s
976 - # alleged support for a variable argument count, but this seems
977 - # to have been broken in WordPress 1.5. It'll be fixed somehow
978 - # in WP 1.5.1, but I'm aiming at WP 1.5 compatibility across
979 - # the board here.
980 - #
981 - # Cf.: <http://mosquito.wordpress.org/view.php?id=901>
982 - global $fwp_channel, $fwp_feedmeta;
983 - $fwp_channel = $feed; $fwp_feedmeta = $feedmeta;
984 -
985 - $this->feed = $feed;
986 - $this->feedmeta = $feedmeta;
987 -
988 - $this->item = $item;
989 - $this->item = apply_filters('syndicated_item', $this->item, $this);
990 -
991 - # Filters can halt further processing by returning NULL
992 - if (is_null($this->item)) :
993 - $this->post = NULL;
994 - else :
995 - # Note that nothing is run through $wpdb->escape() here.
996 - # That's deliberate. The escaping is done at the point
997 - # of insertion, not here, to avoid double-escaping and
998 - # to avoid screwing with syndicated_post filters
999 -
1000 - $this->post['post_title'] = apply_filters('syndicated_item_title', $this->item['title'], $this);
1001 -
1002 - // This just gives us an alphanumeric representation of
1003 - // the author. We will look up (or create) the numeric
1004 - // ID for the author in SyndicatedPost::add()
1005 - $this->post['named']['author'] = apply_filters('syndicated_item_author', $this->author(), $this);
1006 -
1007 - # Identify content and sanitize it.
1008 - # ---------------------------------
1009 - if (isset($this->item['xhtml']['body'])) :
1010 - $content = $this->item['xhtml']['body'];
1011 - elseif (isset($this->item['xhtml']['div'])) :
1012 - $content = $this->item['xhtml']['div'];
1013 - elseif (isset($this->item['content']['encoded']) and $this->item['content']['encoded']):
1014 - $content = $this->item['content']['encoded'];
1015 - else:
1016 - $content = $this->item['description'];
1017 - endif;
1018 - $this->post['post_content'] = apply_filters('syndicated_item_content', $content, $this);
1019 -
1020 - # Identify and sanitize excerpt
1021 - $excerpt = NULL;
1022 - if ( isset($this->item['description']) and $this->item['description'] ) :
1023 - $excerpt = $this->item['description'];
1024 - elseif ( isset($content) and $content ) :
1025 - $excerpt = strip_tags($content);
1026 - if (strlen($excerpt) > 255) :
1027 - $excerpt = substr($excerpt,0,252).'...';
1028 - endif;
1029 - endif;
1030 - $excerpt = apply_filters('syndicated_item_excerpt', $excerpt, $this);
1031 -
1032 - if (!is_null($excerpt)):
1033 - $this->post['post_excerpt'] = $excerpt;
1034 - endif;
1035 -
1036 - // This is unnecessary if we use wp_insert_post
1037 - if (!$this->use_api('wp_insert_post')) :
1038 - $this->post['post_name'] = sanitize_title($this->post['post_title']);
1039 - endif;
1040 -
1041 - $this->post['epoch']['issued'] = apply_filters('syndicated_item_published', $this->published(), $this);
1042 - $this->post['epoch']['created'] = apply_filters('syndicated_item_created', $this->created(), $this);
1043 - $this->post['epoch']['modified'] = apply_filters('syndicated_item_updated', $this->updated(), $this);
1044 -
1045 - // Dealing with timestamps in WordPress is so fucking fucked.
1046 - $offset = (int) get_option('gmt_offset') * 60 * 60;
1047 - $this->post['post_date'] = gmdate('Y-m-d H:i:s', $this->published() + $offset);
1048 - $this->post['post_modified'] = gmdate('Y-m-d H:i:s', $this->updated() + $offset);
1049 - $this->post['post_date_gmt'] = gmdate('Y-m-d H:i:s', $this->published());
1050 - $this->post['post_modified_gmt'] = gmdate('Y-m-d H:i:s', $this->updated());
1051 -
1052 - // Use feed-level preferences or the global default.
1053 - $this->post['post_status'] = $this->link->syndicated_status('post', 'publish');
1054 - $this->post['comment_status'] = $this->link->syndicated_status('comment', 'closed');
1055 - $this->post['ping_status'] = $this->link->syndicated_status('ping', 'closed');
1056 -
1057 - // Unique ID (hopefully a unique tag: URI); failing that, the permalink
1058 - $this->post['guid'] = apply_filters('syndicated_item_guid', $this->guid(), $this);
1059 -
1060 - // RSS 2.0 / Atom 1.0 enclosure support
1061 - if ( isset($this->item['enclosure#']) ) :
1062 - for ($i = 1; $i <= $this->item['enclosure#']; $i++) :
1063 - $eid = (($i > 1) ? "#{$id}" : "");
1064 - $this->post['meta']['enclosure'][] =
1065 - apply_filters('syndicated_item_enclosure_url', $this->item["enclosure{$eid}@url"], $this)."\n".
1066 - apply_filters('syndicated_item_enclosure_length', $this->item["enclosure{$eid}@length"], $this)."\n".
1067 - apply_filters('syndicated_item_enclosure_type', $this->item["enclosure{$eid}@type"], $this);
1068 - endfor;
1069 - endif;
1070 -
1071 - // In case you want to point back to the blog this was syndicated from
1072 - if (isset($this->feed->channel['title'])) :
1073 - $this->post['meta']['syndication_source'] = apply_filters('syndicated_item_source_title', $this->feed->channel['title'], $this);
1074 - endif;
1075 -
1076 - if (isset($this->feed->channel['link'])) :
1077 - $this->post['meta']['syndication_source_uri'] = apply_filters('syndicated_item_source_link', $this->feed->channel['link'], $this);
1078 - endif;
1079 -
1080 - // Make use of atom:source data, if present in an aggregated feed
1081 - if (isset($this->item['source_title'])) :
1082 - $this->post['meta']['syndication_source_original'] = $this->item['source_title'];
1083 - endif;
1084 -
1085 - if (isset($this->item['source_link'])) :
1086 - $this->post['meta']['syndication_source_uri_original'] = $this->item['source_link'];
1087 - endif;
1088 -
1089 - if (isset($this->item['source_id'])) :
1090 - $this->post['meta']['syndication_source_id_original'] = $this->item['source_id'];
1091 - endif;
1092 -
1093 - // Store information on human-readable and machine-readable comment URIs
1094 - if (isset($this->item['comments'])) :
1095 - $this->post['meta']['rss:comments'] = apply_filters('syndicated_item_comments', $this->item['comments']);
1096 - endif;
1097 - if (isset($this->item['wfw']['commentrss'])) :
1098 - $this->post['meta']['wfw:commentRSS'] = apply_filters('syndicated_item_commentrss', $this->item['wfw']['commentrss']);
1099 - endif;
1100 -
1101 - // Store information to identify the feed that this came from
1102 - $this->post['meta']['syndication_feed'] = $this->feedmeta['link/uri'];
1103 - $this->post['meta']['syndication_feed_id'] = $this->feedmeta['link/id'];
1104 -
1105 - if (isset($this->item['source_link_self'])) :
1106 - $this->post['meta']['syndication_feed_original'] = $this->item['source_link_self'];
1107 - endif;
1108 -
1109 - // In case you want to know the external permalink...
1110 - $this->post['meta']['syndication_permalink'] = apply_filters('syndicated_item_link', $this->item['link']);
1111 -
1112 - // Store a hash of the post content for checking whether something needs to be updated
1113 - $this->post['meta']['syndication_item_hash'] = $this->update_hash();
1114 -
1115 - // Feed-by-feed options for author and category creation
1116 - $this->post['named']['unfamiliar']['author'] = $this->feedmeta['unfamiliar author'];
1117 - $this->post['named']['unfamiliar']['category'] = $this->feedmeta['unfamiliar category'];
1118 -
1119 - // Categories: start with default categories, if any
1120 - $fc = get_option("feedwordpress_syndication_cats");
1121 - if ($fc) :
1122 - $this->post['named']['preset/category'] = explode("\n", $fc);
1123 - else :
1124 - $this->post['named']['preset/category'] = array();
1125 - endif;
1126 -
1127 - if (is_array($this->feedmeta['cats'])) :
1128 - $this->post['named']['preset/category'] = array_merge($this->post['named']['preset/category'], $this->feedmeta['cats']);
1129 - endif;
1130 -
1131 - // Now add categories from the post, if we have 'em
1132 - $this->post['named']['category'] = array();
1133 - if ( isset($this->item['category#']) ) :
1134 - for ($i = 1; $i <= $this->item['category#']; $i++) :
1135 - $cat_idx = (($i > 1) ? "#{$i}" : "");
1136 - $cat = $this->item["category{$cat_idx}"];
1137 -
1138 - if ( isset($this->feedmeta['cat_split']) and strlen($this->feedmeta['cat_split']) > 0) :
1139 - $pcre = "\007".$this->feedmeta['cat_split']."\007";
1140 - $this->post['named']['category'] = array_merge($this->post['named']['category'], preg_split($pcre, $cat, -1 /*=no limit*/, PREG_SPLIT_NO_EMPTY));
1141 - else :
1142 - $this->post['named']['category'][] = $cat;
1143 - endif;
1144 - endfor;
1145 - endif;
1146 - $this->post['named']['category'] = apply_filters('syndicated_item_categories', $this->post['named']['category'], $this);
1147 -
1148 - // Tags: start with default tags, if any
1149 - $ft = get_option("feedwordpress_syndication_tags");
1150 - if ($ft) :
1151 - $this->post['tags_input'] = explode('FEEDWORDPRESS_CAT_SEPARATOR', $ft);
1152 - else :
1153 - $this->post['tags_input'] = array();
1154 - endif;
1155 -
1156 - if (is_array($this->feedmeta['tags'])) :
1157 - $this->post['tags_input'] = array_merge($this->post['tags_input'], $this->feedmeta['tags']);
1158 - endif;
1159 -
1465 + function noncritical_bug ($varname, $var, $line) {
1466 + if (FEEDWORDPRESS_DEBUG) : // halt only when we are doing debugging
1467 + FeedWordPress::critical_bug($varname, $var, $line);
1160 1468 endif;
1161 - } // SyndicatedPost::SyndicatedPost()
1162 -
1163 - function filtered () {
1164 - return is_null($this->post);
1165 1469 }
1166 -
1167 - function freshness () {
1168 - global $wpdb;
1169 -
1170 - if ($this->filtered()) : // This should never happen.
1171 - FeedWordPress::critical_bug('SyndicatedPost', $this, __LINE__);
1172 - endif;
1173 -
1174 - if (is_null($this->_freshness)) :
1175 - $guid = $wpdb->escape($this->guid());
1176 -
1177 - $result = $wpdb->get_row("
1178 - SELECT id, guid, post_modified_gmt
1179 - FROM $wpdb->posts WHERE guid='$guid'
1180 - ");
1181 -
1182 - if (!$result) :
1183 - $this->_freshness = 2; // New content
1184 - else:
1185 - $stored_update_hashes = get_post_custom_values('syndication_item_hash', $result->id);
1186 - if (count($stored_update_hashes) > 0) :
1187 - $stored_update_hash = $stored_update_hashes[0];
1188 - $update_hash_changed = ($stored_update_hash != $this->update_hash());
1189 - else :
1190 - $update_hash_changed = false;
1191 - endif;
1192 -
1193 - preg_match('/([0-9]+)-([0-9]+)-([0-9]+) ([0-9]+):([0-9]+):([0-9]+)/', $result->post_modified_gmt, $backref);
1194 -
1195 - $last_rev_ts = gmmktime($backref[4], $backref[5], $backref[6], $backref[2], $backref[3], $backref[1]);
1196 - $updated_ts = $this->updated(/*fallback=*/ true, /*default=*/ NULL);
1197 - $updated = ((
1198 - !is_null($updated_ts)
1199 - and ($updated_ts > $last_rev_ts)
1200 - ) or $update_hash_changed);
1201 -
1202 - if ($updated) :
1203 - $this->_freshness = 1; // Updated content
1204 - $this->_wp_id = $result->id;
1205 - else :
1206 - $this->_freshness = 0; // Same old, same old
1207 - $this->_wp_id = $result->id;
1208 - endif;
1209 - endif;
1210 - endif;
1211 - return $this->_freshness;
1212 - }
1213 -
1214 - function wp_id () {
1215 - if ($this->filtered()) : // This should never happen.
1216 - FeedWordPress::critical_bug('SyndicatedPost', $this, __LINE__);
1217 - endif;
1218 -
1219 - if (is_null($this->_wp_id) and is_null($this->_freshness)) :
1220 - $fresh = $this->freshness(); // sets WP DB id in the process
1221 - endif;
1222 - return $this->_wp_id;
1223 - }
1224 -
1225 - function store () {
1226 - global $wpdb;
1227 -
1228 - if ($this->filtered()) : // This should never happen.
1229 - FeedWordPress::critical_bug('SyndicatedPost', $this, __LINE__);
1230 - endif;
1231 -
1232 - $freshness = $this->freshness();
1233 - if ($freshness > 0) :
1234 - # -- Look up, or create, numeric ID for author
1235 - $this->post['post_author'] = $this->author_id (
1236 - FeedWordPress::on_unfamiliar('author', $this->post['named']['unfamiliar']['author'])
1237 - );
1238 -
1239 - if (is_null($this->post['post_author'])) :
1240 - $this->post = NULL;
1241 - endif;
1242 - endif;
1243 -
1244 - if (!$this->filtered() and $freshness > 0) :
1245 - # -- Look up, or create, numeric ID for categories
1246 - list($pcats, $ptags) = $this->category_ids (
1247 - $this->post['named']['category'],
1248 - FeedWordPress::on_unfamiliar('category', $this->post['named']['unfamiliar']['category']),
1249 - /*tags_too=*/ true
1250 - );
1251 -
1252 - $this->post['post_category'] = $pcats;
1253 - $this->post['tags_input'] = array_merge($this->post['tags_input'], $ptags);
1254 -
1255 - if (is_null($this->post['post_category'])) :
1256 - // filter mode on, no matching categories; drop the post
1257 - $this->post = NULL;
1258 - else :
1259 - // filter mode off or at least one match; now add on the feed and global presets
1260 - $this->post['post_category'] = array_merge (
1261 - $this->post['post_category'],
1262 - $this->category_ids (
1263 - $this->post['named']['preset/category'],
1264 - 'default'
1265 - )
1266 - );
1267 -
1268 - if (count($this->post['post_category']) < 1) :
1269 - $this->post['post_category'][] = 1; // Default to category 1 ("Uncategorized" / "General") if nothing else
1270 - endif;
1271 - endif;
1272 - endif;
1273 -
1274 - if (!$this->filtered() and $freshness > 0) :
1275 - unset($this->post['named']);
1276 - $this->post = apply_filters('syndicated_post', $this->post, $this);
1277 - endif;
1278 -
1279 - if (!$this->filtered() and $freshness == 2) :
1280 - // The item has not yet been added. So let's add it.
1281 - $this->insert_new();
1282 - $this->add_rss_meta();
1283 - do_action('post_syndicated_item', $this->wp_id());
1284 -
1285 - $ret = 'new';
1286 - elseif (!$this->filtered() and $freshness == 1) :
1287 - $this->post['ID'] = $this->wp_id();
1288 - $this->update_existing();
1289 - $this->add_rss_meta();
1290 - do_action('update_syndicated_item', $this->wp_id());
1291 -
1292 - $ret = 'updated';
1293 - else :
1294 - $ret = false;
1295 - endif;
1296 -
1297 - return $ret;
1298 - } // function SyndicatedPost::store ()
1299 1470
1300 - function insert_new () {
1301 - global $wpdb, $wp_db_version;
1471 + function val ($v, $no_newlines = false) {
1472 + ob_start();
1473 + var_dump($v);
1474 + $out = ob_get_contents(); ob_end_clean();
1302 1475
1303 - // Why the fuck doesn't wp_insert_post already do this?
1304 - foreach ($this->post as $key => $value) :
1305 - if (is_string($value)) :
1306 - $dbpost[$key] = $wpdb->escape($value);
1307 - else :
1308 - $dbpost[$key] = $value;
1309 - endif;
1310 - endforeach;
1311 -
1312 - if (strlen($dbpost['post_title'].$dbpost['post_content'].$dbpost['post_excerpt']) == 0) :
1313 - // FIXME: Option for filtering out empty posts
1476 + if ($no_newlines) :
1477 + $out = preg_replace('/\s+/', " ", $out);
1314 1478 endif;
1315 - if (strlen($dbpost['post_title'])==0) :
1316 - $dbpost['post_title'] = $this->post['meta']['syndication_source']
1317 - .' '.gmdate('Y-m-d H:i:s', $this->published() + $offset);
1318 - // FIXME: Option for what to fill a blank title with...
1319 - endif;
1479 + return $out;
1480 + } /* FeedWordPress:val () */
1320 1481
1321 - if ($this->use_api('wp_insert_post')) :
1322 - $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1482 + function diagnostic ($level, $out) {
1483 + global $feedwordpress_admin_footer;
1323 1484
1324 - // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1325 - add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1326 -
1327 - // Kludge to prevent kses filters from stripping the
1328 - // content of posts when updating without a logged in
1329 - // user who has `unfiltered_html` capability.
1330 - add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1331 -
1332 - $this->_wp_id = wp_insert_post($dbpost);
1333 -
1334 - // Turn off ridiculous fucking kludges #1 and #2
1335 - remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1336 - remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1337 -
1338 - // This should never happen.
1339 - if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1340 - FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1341 - endif;
1342 -
1343 - // Unfortunately, as of WordPress 2.3, wp_insert_post()
1344 - // *still* offers no way to use a guid of your choice,
1345 - // and munges your post modified timestamp, too.
1346 - $result = $wpdb->query("
1347 - UPDATE $wpdb->posts
1348 - SET
1349 - guid='{$dbpost['guid']}',
1350 - post_modified='{$dbpost['post_modified']}',
1351 - post_modified_gmt='{$dbpost['post_modified_gmt']}'
1352 - WHERE ID='{$this->_wp_id}'
1353 - ");
1354 - else :
1355 - # The right way to do this is the above. But, alas,
1356 - # in earlier versions of WordPress, wp_insert_post has
1357 - # too much behavior (mainly related to pings) that can't
1358 - # be overridden. In WordPress 1.5, it's enough of a
1359 - # resource hog to make PHP segfault after inserting
1360 - # 50-100 posts. This can get pretty annoying, especially
1361 - # if you are trying to update your feeds for the first
1362 - # time.
1363 -
1364 - $result = $wpdb->query("
1365 - INSERT INTO $wpdb->posts
1366 - SET
1367 - guid = '{$dbpost['guid']}',
1368 - post_author = '{$dbpost['post_author']}',
1369 - post_date = '{$dbpost['post_date']}',
1370 - post_date_gmt = '{$dbpost['post_date_gmt']}',
1371 - post_content = '{$dbpost['post_content']}',"
1372 - .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1373 - post_title = '{$dbpost['post_title']}',
1374 - post_name = '{$dbpost['post_name']}',
1375 - post_modified = '{$dbpost['post_modified']}',
1376 - post_modified_gmt = '{$dbpost['post_modified_gmt']}',
1377 - comment_status = '{$dbpost['comment_status']}',
1378 - ping_status = '{$dbpost['ping_status']}',
1379 - post_status = '{$dbpost['post_status']}'
1380 - ");
1381 - $this->_wp_id = $wpdb->insert_id;
1382 -
1383 - // This should never happen.
1384 - if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1385 - FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1386 - endif;
1387 -
1388 - // WordPress 1.5.x - 2.0.x
1389 - wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1390 -
1391 - // Since we are not going through official channels, we need to
1392 - // manually tell WordPress that we've published a new post.
1393 - // We need to make sure to do this in order for FeedWordPress
1394 - // to play well with the staticize-reloaded plugin (something
1395 - // that a large aggregator website is going to *want* to be
1396 - // able to use).
1397 - do_action('publish_post', $this->_wp_id);
1398 - endif;
1399 - } /* SyndicatedPost::insert_new() */
1400 -
1401 - function update_existing () {
1402 - global $wpdb;
1403 -
1404 - // Why the fuck doesn't wp_insert_post already do this?
1405 - $dbpost = array();
1406 - foreach ($this->post as $key => $value) :
1407 - if (is_string($value)) :
1408 - $dbpost[$key] = $wpdb->escape($value);
1409 - else :
1410 - $dbpost[$key] = $value;
1411 - endif;
1412 - endforeach;
1413 -
1414 - if ($this->use_api('wp_insert_post')) :
1415 - $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1416 -
1417 - // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1418 - add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1419 -
1420 - // Kludge to prevent kses filters from stripping the
1421 - // content of posts when updating without a logged in
1422 - // user who has `unfiltered_html` capability.
1423 - add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1424 -
1425 - $this->_wp_id = wp_insert_post($dbpost);
1426 -
1427 - // Turn off ridiculous fucking kludges #1 and #2
1428 - remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1429 - remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1430 -
1431 - // This should never happen.
1432 - if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1433 - FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1434 - endif;
1435 -
1436 - // Unfortunately, as of WordPress 2.3, wp_insert_post()
1437 - // munges your post modified timestamp.
1438 - $result = $wpdb->query("
1439 - UPDATE $wpdb->posts
1440 - SET
1441 - post_modified='{$dbpost['post_modified']}',
1442 - post_modified_gmt='{$dbpost['post_modified_gmt']}'
1443 - WHERE ID='{$this->_wp_id}'
1444 - ");
1445 - else :
1446 -
1447 - $result = $wpdb->query("
1448 - UPDATE $wpdb->posts
1449 - SET
1450 - post_author = '{$dbpost['post_author']}',
1451 - post_content = '{$dbpost['post_content']}',"
1452 - .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1453 - post_title = '{$dbpost['post_title']}',
1454 - post_name = '{$dbpost['post_name']}',
1455 - post_modified = '{$dbpost['post_modified']}',
1456 - post_modified_gmt = '{$dbpost['post_modified_gmt']}'
1457 - WHERE guid='{$dbpost['guid']}'
1458 - ");
1459 -
1460 - // WordPress 2.1.x and up
1461 - if (function_exists('wp_set_post_categories')) :
1462 - wp_set_post_categories($this->wp_id(), $this->post['post_category']);
1463 - // WordPress 1.5.x - 2.0.x
1464 - elseif (function_exists('wp_set_post_cats')) :
1465 - wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1466 - // This should never happen.
1467 - else :
1468 - FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1469 - endif;
1470 -
1471 - // Since we are not going through official channels, we need to
1472 - // manually tell WordPress that we've published a new post.
1473 - // We need to make sure to do this in order for FeedWordPress
1474 - // to play well with the staticize-reloaded plugin (something
1475 - // that a large aggregator website is going to *want* to be
1476 - // able to use).
1477 - do_action('edit_post', $this->post['ID']);
1478 - endif;
1479 - } /* SyndicatedPost::update_existing() */
1480 -
1481 - /**
1482 - * SyndicatedPost::fix_revision_meta() - Fixes the way WP 2.6+ fucks up
1483 - * meta-data (authorship, etc.) when storing revisions of an updated
1484 - * syndicated post.
1485 - *
1486 - * In their infinite wisdom, the WordPress coders have made it completely
1487 - * impossible for a plugin that uses wp_insert_post() to set certain
1488 - * meta-data (such as the author) when you store an old revision of an
1489 - * updated post. Instead, it uses the WordPress defaults (= currently
1490 - * active user ID if the process is running with a user logged in, or
1491 - * = #0 if there is no user logged in). This results in bogus authorship
1492 - * data for revisions that are syndicated from off the feed, unless we
1493 - * use a ridiculous kludge like this to end-run the munging of meta-data
1494 - * by _wp_put_post_revision.
1495 - *
1496 - * @param int $revision_id The revision ID to fix up meta-data
1497 - */
1498 - function fix_revision_meta ($revision_id) {
1499 - global $wpdb;
1485 + $output = get_option('feedwordpress_diagnostics_output', array());
1486 + $show = get_option('feedwordpress_diagnostics_show', array());
1500 1487
1501 - $post_author = (int) $this->post['post_author'];
1502 -
1503 - $revision_id = (int) $revision_id;
1504 - $wpdb->query("
1505 - UPDATE $wpdb->posts
1506 - SET post_author={$this->post['post_author']}
1507 - WHERE post_type = 'revision' AND ID='$revision_id'
1508 - ");
1509 - } /* SyndicatedPost::fix_revision_meta () */
1488 + $diagnostic_nesting = count(explode(":", $level));
1510 1489
1511 - /**
1512 - * SyndicatedPost::avoid_kses_munge() -- If FeedWordPress is processing
1513 - * an automatic update, that generally means that wp_insert_post() is
1514 - * being called under the user credentials of whoever is viewing the
1515 - * blog at the time -- usually meaning no user at all. But if WordPress
1516 - * gets a wp_insert_post() when current_user_can('unfiltered_html') is
1517 - * false, it will run the content of the post through a kses function
1518 - * that strips out lots of HTML tags -- notably <object> and some others.
1519 - * This causes problems for syndicating (for example) feeds that contain
1520 - * YouTube videos. It also produces an unexpected asymmetry between
1521 - * automatically-initiated updates and updates initiated manually from
1522 - * the WordPress Dashboard (which are usually initiated under the
1523 - * credentials of a logged-in admin, and so don't get run through the
1524 - * kses function). So, to avoid the whole mess, what we do here is
1525 - * just forcibly disable the kses munging for a single syndicated post,
1526 - * by restoring the contents of the `post_content` field.
1527 - *
1528 - * @param string $content The content of the post, after other filters have gotten to it
1529 - * @return string The original content of the post, before other filters had a chance to munge it.
1530 - */
1531 - function avoid_kses_munge ($content) {
1532 - global $wpdb;
1533 - return $wpdb->escape($this->post['post_content']);
1534 - }
1535 -
1536 - // SyndicatedPost::add_rss_meta: adds interesting meta-data to each entry
1537 - // using the space for custom keys. The set of keys and values to add is
1538 - // specified by the keys and values of $post['meta']. This is used to
1539 - // store anything that the WordPress user might want to access from a
1540 - // template concerning the post's original source that isn't provided
1541 - // for by standard WP meta-data (i.e., any interesting data about the
1542 - // syndicated post other than author, title, timestamp, categories, and
1543 - // guid). It's also used to hook into WordPress's support for
1544 - // enclosures.
1545 - function add_rss_meta () {
1546 - global $wpdb;
1547 - if ( is_array($this->post) and isset($this->post['meta']) and is_array($this->post['meta']) ) :
1548 - $postId = $this->wp_id();
1549 -
1550 - // Aggregated posts should NOT send out pingbacks.
1551 - // WordPress 2.1-2.2 claim you can tell them not to
1552 - // using $post_pingback, but they don't listen, so we
1553 - // make sure here.
1554 - $result = $wpdb->query("
1555 - DELETE FROM $wpdb->postmeta
1556 - WHERE post_id='$postId' AND meta_key='_pingme'
1557 - ");
1558 -
1559 - foreach ( $this->post['meta'] as $key => $values ) :
1560 -
1561 - $key = $wpdb->escape($key);
1562 -
1563 - // If this is an update, clear out the old
1564 - // values to avoid duplication.
1565 - $result = $wpdb->query("
1566 - DELETE FROM $wpdb->postmeta
1567 - WHERE post_id='$postId' AND meta_key='$key'
1568 - ");
1569 -
1570 - // Allow for either a single value or an array
1571 - if (!is_array($values)) $values = array($values);
1572 - foreach ( $values as $value ) :
1573 - $value = $wpdb->escape($value);
1574 - $result = $wpdb->query("
1575 - INSERT INTO $wpdb->postmeta
1576 - SET
1577 - post_id='$postId',
1578 - meta_key='$key',
1579 - meta_value='$value'
1580 - ");
1581 - endforeach;
1490 + if (in_array($level, $show)) :
1491 + foreach ($output as $method) :
1492 + switch ($method) :
1493 + case 'echo' :
1494 + echo "<div><pre><strong>Diag".str_repeat('====', $diagnostic_nesting-1).'|</strong> '.esc_html($out)."</pre></div>";
1495 + break;
1496 + case 'admin_footer' :
1497 + $feedwordpress_admin_footer[] = $out;
1498 + break;
1499 + case 'error_log' :
1500 + error_log('[feedwordpress]' . $out);
1501 + break;
1502 + endswitch;
1582 1503 endforeach;
1583 1504 endif;
1584 - } /* SyndicatedPost::add_rss_meta () */
1585 -
1586 - // SyndicatedPost::author_id (): get the ID for an author name from
1587 - // the feed. Create the author if necessary.
1588 - function author_id ($unfamiliar_author = 'create') {
1589 - global $wpdb;
1590 -
1591 - $a = $this->author();
1592 - $author = $a['name'];
1593 - $email = $a['email'];
1594 - $url = $a['uri'];
1595 -
1596 - $match_author_by_email = !('yes' == get_option("feedwordpress_do_not_match_author_by_email"));
1597 - if ($match_author_by_email and !FeedWordPress::is_null_email($email)) :
1598 - $test_email = $email;
1599 - else :
1600 - $test_email = NULL;
1601 - endif;
1602 -
1603 - // Never can be too careful...
1604 - $login = sanitize_user($author, /*strict=*/ true);
1605 - $login = apply_filters('pre_user_login', $login);
1606 -
1607 - $nice_author = sanitize_title($author);
1608 - $nice_author = apply_filters('pre_user_nicename', $nice_author);
1609 -
1610 - $reg_author = $wpdb->escape(preg_quote($author));
1611 - $author = $wpdb->escape($author);
1612 - $email = $wpdb->escape($email);
1613 - $test_email = $wpdb->escape($test_email);
1614 - $url = $wpdb->escape($url);
1615 -
1616 - // Check for an existing author rule....
1617 - if (isset($this->link->settings['map authors']['name'][strtolower(trim($author))])) :
1618 - $author_rule = $this->link->settings['map authors']['name'][strtolower(trim($author))];
1619 - else :
1620 - $author_rule = NULL;
1621 - endif;
1622 -
1623 - // User name is mapped to a particular author. If that author ID exists, use it.
1624 - if (is_numeric($author_rule) and get_userdata((int) $author_rule)) :
1625 - $id = (int) $author_rule;
1626 -
1627 - // User name is filtered out
1628 - elseif ('filter' == $author_rule) :
1629 - $id = NULL;
1630 -
1631 - else :
1632 - // Check the database for an existing author record that might fit
1633 -
1634 - #-- WordPress 2.0+
1635 - if (fwp_test_wp_version(FWP_SCHEMA_HAS_USERMETA)) :
1636 -
1637 - // First try the user core data table.
1638 - $id = $wpdb->get_var(
1639 - "SELECT ID FROM $wpdb->users
1640 - WHERE
1641 - TRIM(LCASE(user_login)) = TRIM(LCASE('$login'))
1642 - OR (
1643 - LENGTH(TRIM(LCASE(user_email))) > 0
1644 - AND TRIM(LCASE(user_email)) = TRIM(LCASE('$test_email'))
1645 - )
1646 - OR TRIM(LCASE(user_nicename)) = TRIM(LCASE('$nice_author'))
1647 - ");
1505 + } /* FeedWordPress::diagnostic () */
1648 1506
1649 - // If that fails, look for aliases in the user meta data table
1650 - if (is_null($id)) :
1651 - $id = $wpdb->get_var(
1652 - "SELECT user_id FROM $wpdb->usermeta
1653 - WHERE
1654 - (meta_key = 'description' AND TRIM(LCASE(meta_value)) = TRIM(LCASE('$author')))
1655 - OR (
1656 - meta_key = 'description'
1657 - AND TRIM(LCASE(meta_value))
1658 - RLIKE CONCAT(
1659 - '(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*',
1660 - TRIM(LCASE('$reg_author')),
1661 - '( |\\t|\\r)*(\\n|\$)'
1662 - )
1663 - )
1664 - ");
1665 - endif;
1666 -
1667 - #-- WordPress 1.5.x
1668 - else :
1669 - $id = $wpdb->get_var(
1670 - "SELECT ID from $wpdb->users
1671 - WHERE
1672 - TRIM(LCASE(user_login)) = TRIM(LCASE('$login')) OR
1673 - (
1674 - LENGTH(TRIM(LCASE(user_email))) > 0
1675 - AND TRIM(LCASE(user_email)) = TRIM(LCASE('$test_email'))
1676 - ) OR
1677 - TRIM(LCASE(user_firstname)) = TRIM(LCASE('$author')) OR
1678 - TRIM(LCASE(user_nickname)) = TRIM(LCASE('$author')) OR
1679 - TRIM(LCASE(user_nicename)) = TRIM(LCASE('$nice_author')) OR
1680 - TRIM(LCASE(user_description)) = TRIM(LCASE('$author')) OR
1681 - (
1682 - LOWER(user_description)
1683 - RLIKE CONCAT(
1684 - '(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*',
1685 - LCASE('$reg_author'),
1686 - '( |\\t|\\r)*(\\n|\$)'
1687 - )
1688 - )
1689 - ");
1690 -
1691 - endif;
1692 -
1693 - // ... if you don't find one, then do what you need to do
1694 - if (is_null($id)) :
1695 - if ($unfamiliar_author === 'create') :
1696 - $userdata = array();
1697 -
1698 - #-- user table data
1699 - $userdata['ID'] = NULL; // new user
1700 - $userdata['user_login'] = $login;
1701 - $userdata['user_nicename'] = $nice_author;
1702 - $userdata['user_pass'] = substr(md5(uniqid(microtime())), 0, 6); // just something random to lock it up
1703 - $userdata['user_email'] = $email;
1704 - $userdata['user_url'] = $url;
1705 - $userdata['display_name'] = $author;
1706 -
1707 - $id = wp_insert_user($userdata);
1708 - elseif (is_numeric($unfamiliar_author) and get_userdata((int) $unfamiliar_author)) :
1709 - $id = (int) $unfamiliar_author;
1710 - elseif ($unfamiliar_author === 'default') :
1711 - $id = 1;
1712 - endif;
1713 - endif;
1714 - endif;
1715 -
1716 - if ($id) :
1717 - $this->link->settings['map authors']['name'][strtolower(trim($author))] = $id;
1718 - endif;
1719 - return $id;
1720 - } // function SyndicatedPost::author_id ()
1721 -
1722 - // look up (and create) category ids from a list of categories
1723 - function category_ids ($cats, $unfamiliar_category = 'create', $tags_too = false) {
1724 - global $wpdb;
1725 -
1726 - // We need to normalize whitespace because (1) trailing
1727 - // whitespace can cause PHP and MySQL not to see eye to eye on
1728 - // VARCHAR comparisons for some versions of MySQL (cf.
1729 - // <http://dev.mysql.com/doc/mysql/en/char.html>), and (2)
1730 - // because I doubt most people want to make a semantic
1731 - // distinction between 'Computers' and 'Computers '
1732 - $cats = array_map('trim', $cats);
1733 -
1734 - $tags = array();
1735 -
1736 - $cat_ids = array ();
1737 - foreach ($cats as $cat_name) :
1738 - if (preg_match('/^{#([0-9]+)}$/', $cat_name, $backref)) :
1739 - $cat_id = (int) $backref[1];
1740 - if (function_exists('is_term') and is_term($cat_id, 'category')) :
1741 - $cat_ids[] = $cat_id;
1742 - elseif (get_category($cat_id)) :
1743 - $cat_ids[] = $cat_id;
1744 - endif;
1745 - else :
1746 - $esc = $wpdb->escape($cat_name);
1747 - $resc = $wpdb->escape(preg_quote($cat_name));
1748 -
1749 - // WordPress 2.3+
1750 - if (function_exists('is_term')) :
1751 - $cat_id = is_term($cat_name, 'category');
1752 - if ($cat_id) :
1753 - $cat_ids[] = $cat_id['term_id'];
1754 - // There must be a better way to do this...
1755 - elseif ($results = $wpdb->get_results(
1756 - "SELECT term_id
1757 - FROM $wpdb->term_taxonomy
1758 - WHERE
1759 - LOWER(description) RLIKE
1760 - CONCAT('(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*', LOWER('{$resc}'), '( |\\t|\\r)*(\\n|\$)')"
1761 - )) :
1762 - foreach ($results AS $term) :
1763 - $cat_ids[] = (int) $term->term_id;
1764 - endforeach;
1765 - elseif ('tag'==$unfamiliar_category) :
1766 - $tags[] = $cat_name;
1767 - elseif ('create'===$unfamiliar_category) :
1768 - $term = wp_insert_term($cat_name, 'category');
1769 - $cat_ids[] = $term['term_id'];
1770 - endif;
1771 -
1772 - // WordPress 1.5.x - 2.2.x
1773 - else :
1774 - $results = $wpdb->get_results(
1775 - "SELECT cat_ID
1776 - FROM $wpdb->categories
1777 - WHERE
1778 - (LOWER(cat_name) = LOWER('$esc'))
1779 - OR (LOWER(category_description)
1780 - RLIKE CONCAT('(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*', LOWER('{$resc}'), '( |\\t|\\r)*(\\n|\$)'))
1781 - ");
1782 - if ($results) :
1783 - foreach ($results as $term) :
1784 - $cat_ids[] = (int) $term->cat_ID;
1785 - endforeach;
1786 - elseif ('create'===$unfamiliar_category) :
1787 - if (function_exists('wp_insert_category')) :
1788 - $cat_id = wp_insert_category(array('cat_name' => $cat_name));
1789 - // And into the database we go.
1790 - else :
1791 - $nice_kitty = sanitize_title($cat_name);
1792 - $wpdb->query(sprintf("
1793 - INSERT INTO $wpdb->categories
1794 - SET
1795 - cat_name='%s',
1796 - category_nicename='%s'
1797 - ", $wpdb->escape($cat_name), $nice_kitty
1798 - ));
1799 - $cat_id = $wpdb->insert_id;
1800 - endif;
1801 - $cat_ids[] = $cat_id;
1802 - endif;
1803 - endif;
1804 - endif;
1507 + function admin_footer () {
1508 + global $feedwordpress_admin_footer;
1509 + foreach ($feedwordpress_admin_footer as $line) :
1510 + echo '<div><pre>'.esc_html($line).'</pre></div>';
1805 1511 endforeach;
1512 + } /* FeedWordPress::admin_footer () */
1513 +} // class FeedWordPress
1806 1514
1807 - if ((count($cat_ids) == 0) and ($unfamiliar_category === 'filter')) :
1808 - $cat_ids = NULL; // Drop the post
1809 - else :
1810 - $cat_ids = array_unique($cat_ids);
1811 - endif;
1812 -
1813 - if ($tags_too) : $ret = array($cat_ids, $tags);
1814 - else : $ret = $cat_ids;
1815 - endif;
1515 +$feedwordpress_admin_footer = array();
1816 1516
1817 - return $ret;
1818 - } // function SyndicatedPost::category_ids ()
1517 +require_once(dirname(__FILE__) . '/syndicatedpost.class.php');
1518 +require_once(dirname(__FILE__) . '/syndicatedlink.class.php');
1819 1519
1820 - function use_api ($tag) {
1821 - global $wp_db_version;
1822 - switch ($tag) :
1823 - case 'wp_insert_post':
1824 - // Before 2.2, wp_insert_post does too much of the wrong stuff to use it
1825 - // In 1.5 it was such a resource hog it would make PHP segfault on big updates
1826 - $ret = (isset($wp_db_version) and $wp_db_version > FWP_SCHEMA_21);
1827 - break;
1828 - case 'post_status_pending':
1829 - $ret = (isset($wp_db_version) and $wp_db_version > FWP_SCHEMA_23);
1830 - break;
1831 - endswitch;
1832 - return $ret;
1833 - } // function SyndicatedPost::use_api ()
1834 -
1835 - #### EXTRACT DATA FROM FEED ITEM ####
1836 -
1837 - function created () {
1838 - $epoch = null;
1839 - if (isset($this->item['dc']['created'])) :
1840 - $epoch = @parse_w3cdtf($this->item['dc']['created']);
1841 - elseif (isset($this->item['dcterms']['created'])) :
1842 - $epoch = @parse_w3cdtf($this->item['dcterms']['created']);
1843 - elseif (isset($this->item['created'])): // Atom 0.3
1844 - $epoch = @parse_w3cdtf($this->item['created']);
1845 - endif;
1846 - return $epoch;
1847 - }
1848 - function published ($fallback = true) {
1849 - $epoch = null;
1850 -
1851 - # RSS is a fucking mess. Figure out whether we have a date in
1852 - # <dc:date>, <issued>, <pubDate>, etc., and get it into Unix
1853 - # epoch format for reformatting. If we can't find anything,
1854 - # we'll use the last-updated time.
1855 - if (isset($this->item['dc']['date'])): // Dublin Core
1856 - $epoch = @parse_w3cdtf($this->item['dc']['date']);
1857 - elseif (isset($this->item['dcterms']['issued'])) : // Dublin Core extensions
1858 - $epoch = @parse_w3cdtf($this->item['dcterms']['issued']);
1859 - elseif (isset($this->item['published'])) : // Atom 1.0
1860 - $epoch = @parse_w3cdtf($this->item['published']);
1861 - elseif (isset($this->item['issued'])): // Atom 0.3
1862 - $epoch = @parse_w3cdtf($this->item['issued']);
1863 - elseif (isset($this->item['pubdate'])): // RSS 2.0
1864 - $epoch = strtotime($this->item['pubdate']);
1865 - elseif ($fallback) : // Fall back to <updated> / <modified> if present
1866 - $epoch = $this->updated(/*fallback=*/ false);
1867 - endif;
1868 -
1869 - # If everything failed, then default to the current time.
1870 - if (is_null($epoch)) :
1871 - if (-1 == $default) :
1872 - $epoch = time();
1873 - else :
1874 - $epoch = $default;
1875 - endif;
1876 - endif;
1877 -
1878 - return $epoch;
1879 - }
1880 - function updated ($fallback = true, $default = -1) {
1881 - $epoch = null;
1882 -
1883 - # As far as I know, only dcterms and Atom have reliable ways to
1884 - # specify when something was *modified* last. If neither is
1885 - # available, then we'll try to get the time of publication.
1886 - if (isset($this->item['dc']['modified'])) : // Not really correct
1887 - $epoch = @parse_w3cdtf($this->item['dc']['modified']);
1888 - elseif (isset($this->item['dcterms']['modified'])) : // Dublin Core extensions
1889 - $epoch = @parse_w3cdtf($this->item['dcterms']['modified']);
1890 - elseif (isset($this->item['modified'])): // Atom 0.3
1891 - $epoch = @parse_w3cdtf($this->item['modified']);
1892 - elseif (isset($this->item['updated'])): // Atom 1.0
1893 - $epoch = @parse_w3cdtf($this->item['updated']);
1894 - elseif ($fallback) : // Fall back to issued / dc:date
1895 - $epoch = $this->published(/*fallback=*/ false, /*default=*/ $default);
1896 - endif;
1897 -
1898 - # If everything failed, then default to the current time.
1899 - if (is_null($epoch)) :
1900 - if (-1 == $default) :
1901 - $epoch = time();
1902 - else :
1903 - $epoch = $default;
1904 - endif;
1905 - endif;
1906 -
1907 - return $epoch;
1908 - }
1909 -
1910 - function update_hash () {
1911 - return md5(serialize($this->item));
1912 - }
1913 -
1914 - function guid () {
1915 - $guid = null;
1916 - if (isset($this->item['id'])): // Atom 0.3 / 1.0
1917 - $guid = $this->item['id'];
1918 - elseif (isset($this->item['atom']['id'])) : // Namespaced Atom
1919 - $guid = $this->item['atom']['id'];
1920 - elseif (isset($this->item['guid'])) : // RSS 2.0
1921 - $guid = $this->item['guid'];
1922 - elseif (isset($this->item['dc']['identifier'])) :// yeah, right
1923 - $guid = $this->item['dc']['identifier'];
1924 - else :
1925 - // The feed does not seem to have provided us with a
1926 - // unique identifier, so we'll have to cobble together
1927 - // a tag: URI that might work for us. The base of the
1928 - // URI will be the host name of the feed source ...
1929 - $bits = parse_url($this->feedmeta['link/uri']);
1930 - $guid = 'tag:'.$bits['host'];
1931 -
1932 - // If we have a date of creation, then we can use that
1933 - // to uniquely identify the item. (On the other hand, if
1934 - // the feed producer was consicentious enough to
1935 - // generate dates of creation, she probably also was
1936 - // conscientious enough to generate unique identifiers.)
1937 - if (!is_null($this->created())) :
1938 - $guid .= '://post.'.date('YmdHis', $this->created());
1939 -
1940 - // Otherwise, use both the URI of the item, *and* the
1941 - // item's title. We have to use both because titles are
1942 - // often not unique, and sometimes links aren't unique
1943 - // either (e.g. Bitch (S)HITLIST, Mozilla Dot Org news,
1944 - // some podcasts). But it's rare to have *both* the same
1945 - // title *and* the same link for two different items. So
1946 - // this is about the best we can do.
1947 - else :
1948 - $guid .= '://'.md5($this->item['link'].'/'.$this->item['title']);
1949 - endif;
1950 - endif;
1951 - return $guid;
1952 - }
1953 -
1954 - function author () {
1955 - $author = array ();
1956 -
1957 - if (isset($this->item['author_name'])):
1958 - $author['name'] = $this->item['author_name'];
1959 - elseif (isset($this->item['dc']['creator'])):
1960 - $author['name'] = $this->item['dc']['creator'];
1961 - elseif (isset($this->item['dc']['contributor'])):
1962 - $author['name'] = $this->item['dc']['contributor'];
1963 - elseif (isset($this->feed->channel['dc']['creator'])) :
1964 - $author['name'] = $this->feed->channel['dc']['creator'];
1965 - elseif (isset($this->feed->channel['dc']['contributor'])) :
1966 - $author['name'] = $this->feed->channel['dc']['contributor'];
1967 - elseif (isset($this->feed->channel['author_name'])) :
1968 - $author['name'] = $this->feed->channel['author_name'];
1969 - elseif ($this->feed->is_rss() and isset($this->item['author'])) :
1970 - // The author element in RSS is allegedly an
1971 - // e-mail address, but lots of people don't use
1972 - // it that way. So let's make of it what we can.
1973 - $author = parse_email_with_realname($this->item['author']);
1974 -
1975 - if (!isset($author['name'])) :
1976 - if (isset($author['email'])) :
1977 - $author['name'] = $author['email'];
1978 - else :
1979 - $author['name'] = $this->feed->channel['title'];
1980 - endif;
1981 - endif;
1982 - else :
1983 - $author['name'] = $this->feed->channel['title'];
1984 - endif;
1985 -
1986 - if (isset($this->item['author_email'])):
1987 - $author['email'] = $this->item['author_email'];
1988 - elseif (isset($this->feed->channel['author_email'])) :
1989 - $author['email'] = $this->feed->channel['author_email'];
1990 - endif;
1991 -
1992 - if (isset($this->item['author_url'])):
1993 - $author['uri'] = $this->item['author_url'];
1994 - elseif (isset($this->feed->channel['author_url'])) :
1995 - $author['uri'] = $this->item['author_url'];
1996 - else:
1997 - $author['uri'] = $this->feed->channel['link'];
1998 - endif;
1999 -
2000 - return $author;
2001 - } // SyndicatedPost::author()
2002 -
2003 - var $strip_attrs = array (
2004 - array('[a-z]+', 'style'),
2005 - array('[a-z]+', 'target'),
2006 - );
2007 - function sanitize_content ($content, $obj) {
2008 - # FeedWordPress used to resolve URIs relative to the
2009 - # feed URI. It now relies on the xml:base support
2010 - # baked in to the MagpieRSS upgrade. So all we do here
2011 - # now is to sanitize problematic attributes.
2012 - #
2013 - # This kind of sucks. I intend to replace it with
2014 - # lib_filter sometime soon.
2015 - foreach ($obj->strip_attrs as $pair):
2016 - list($tag,$attr) = $pair;
2017 - $content = preg_replace (
2018 - ":(<$tag [^>]*)($attr=(\"[^\">]*\"|[^>\\s]+))([^>]*>):i",
2019 - "\\1\\4",
2020 - $content
2021 - );
2022 - endforeach;
2023 - return $content;
2024 - }
2025 -} // class SyndicatedPost
2026 -
2027 -# class SyndicatedLink: represents a syndication feed stored within the
2028 -# WordPress database
2029 -#
2030 -# To keep things compact and editable from within WordPress, we use all the
2031 -# links under a particular category in the WordPress "Blogroll" for the list of
2032 -# feeds to syndicate. "Contributors" is the category used by default; you can
2033 -# configure that under Options --> Syndication.
2034 -#
2035 -# Fields used are:
2036 -#
2037 -# * link_rss: the URI of the Atom/RSS feed to syndicate
2038 -#
2039 -# * link_notes: user-configurable options, with keys and values
2040 -# like so:
2041 -#
2042 -# key: value
2043 -# cats: computers\nweb
2044 -# feed/key: value
2045 -#
2046 -# Keys that start with "feed/" are gleaned from the data supplied
2047 -# by the feed itself, and will be overwritten with each update.
2048 -#
2049 -# Values have linebreak characters escaped with C-style
2050 -# backslashes (so, for example, a newline becomes "\n").
2051 -#
2052 -# The value of `cats` is used as a newline-separated list of
2053 -# default categories for any post coming from a particular feed.
2054 -# (In the example above, any posts from this feed will be placed
2055 -# in the "computers" and "web" categories--*in addition to* any
2056 -# categories that may already be applied to the posts.)
2057 -#
2058 -# Values of keys in link_notes are accessible from templates using
2059 -# the function `get_feed_meta($key)` if this plugin is activated.
2060 -
2061 -class SyndicatedLink {
2062 - var $id = null;
2063 - var $link = null;
2064 - var $settings = array ();
2065 - var $magpie = null;
2066 -
2067 - function SyndicatedLink ($link) {
2068 - global $wpdb;
2069 -
2070 - if (is_object($link)) :
2071 - $this->link = $link;
2072 - $this->id = $link->link_id;
2073 - else :
2074 - $this->id = $link;
2075 - if (function_exists('get_bookmark')) : // WP 2.1+
2076 - $this->link = get_bookmark($link);
2077 - else :
2078 - $this->link = $wpdb->get_row("
2079 - SELECT * FROM $wpdb->links
2080 - WHERE (link_id = '".$wpdb->escape($link)."')"
2081 - );
2082 - endif;
2083 - endif;
2084 -
2085 - if (strlen($this->link->link_rss) > 0) :
2086 - // Read off feed settings from link_notes
2087 - $notes = explode("\n", $this->link->link_notes);
2088 - foreach ($notes as $note):
2089 - list($key, $value) = explode(": ", $note, 2);
2090 -
2091 - if (strlen($key) > 0) :
2092 - // Unescape and trim() off the whitespace.
2093 - // Thanks to Ray Lischner for pointing out the
2094 - // need to trim off whitespace.
2095 - $this->settings[$key] = stripcslashes (trim($value));
2096 - endif;
2097 - endforeach;
2098 -
2099 - // "Magic" feed settings
2100 - $this->settings['link/uri'] = $this->link->link_rss;
2101 - $this->settings['link/name'] = $this->link->link_name;
2102 - $this->settings['link/id'] = $this->link->link_id;
2103 -
2104 - // `hardcode categories` and `unfamiliar categories` are deprecated in favor of `unfamiliar category`
2105 - if (
2106 - isset($this->settings['unfamiliar categories'])
2107 - and !isset($this->settings['unfamiliar category'])
2108 - ) :
2109 - $this->settings['unfamiliar category'] = $this->settings['unfamiliar categories'];
2110 - endif;
2111 - if (
2112 - FeedWordPress::affirmative($this->settings, 'hardcode categories')
2113 - and !isset($this->settings['unfamiliar category'])
2114 - ) :
2115 - $this->settings['unfamiliar category'] = 'default';
2116 - endif;
2117 -
2118 - // Set this up automagically for del.icio.us
2119 - $bits = parse_url($this->link->link_rss);
2120 - $tagspacers = array('del.icio.us', 'feeds.delicious.com');
2121 - if (!isset($this->settings['cat_split']) and in_array($bits['host'], $tagspacers)) :
2122 - $this->settings['cat_split'] = '\s'; // Whitespace separates multiple tags in del.icio.us RSS feeds
2123 - endif;
2124 -
2125 - if (isset($this->settings['cats'])):
2126 - $this->settings['cats'] = preg_split(FEEDWORDPRESS_CAT_SEPARATOR_PATTERN, $this->settings['cats']);
2127 - endif;
2128 - if (isset($this->settings['tags'])):
2129 - $this->settings['tags'] = preg_split(FEEDWORDPRESS_CAT_SEPARATOR_PATTERN, $this->settings['tags']);
2130 - endif;
2131 -
2132 - if (isset($this->settings['map authors'])) :
2133 - $author_rules = explode("\n\n", $this->settings['map authors']);
2134 - $ma = array();
2135 - foreach ($author_rules as $rule) :
2136 - list($rule_type, $author_name, $author_action) = explode("\n", $rule);
2137 -
2138 - // Normalize for case and whitespace
2139 - $rule_type = strtolower(trim($rule_type));
2140 - $author_name = strtolower(trim($author_name));
2141 - $author_action = strtolower(trim($author_action));
2142 -
2143 - $ma[$rule_type][$author_name] = $author_action;
2144 - endforeach;
2145 - $this->settings['map authors'] = $ma;
2146 - endif;
2147 - endif;
2148 - } /* SyndicatedLink::SyndicatedLink () */
2149 -
2150 - function found () {
2151 - return is_object($this->link);
2152 - } /* SyndicatedLink::found () */
2153 -
2154 - function stale () {
2155 - $stale = true;
2156 - if (isset($this->settings['update/hold']) and ($this->settings['update/hold']=='ping')) :
2157 - $stale = false; // don't update on any timed updates; pings only
2158 - elseif (isset($this->settings['update/hold']) and ($this->settings['update/hold']=='next')) :
2159 - $stale = true; // update on the next timed update
2160 - elseif (!isset($this->settings['update/ttl']) or !isset($this->settings['update/last'])) :
2161 - $stale = true; // initial update
2162 - else :
2163 - $after = ((int) $this->settings['update/last'])
2164 - +((int) $this->settings['update/ttl'] * 60);
2165 - $stale = (time() >= $after);
2166 - endif;
2167 - return $stale;
2168 - } /* SyndicatedLink::stale () */
2169 -
2170 - function poll ($crash_ts = NULL) {
2171 - global $wpdb;
2172 -
2173 - $this->magpie = fetch_rss($this->link->link_rss);
2174 - $new_count = NULL;
2175 -
2176 - $resume = FeedWordPress::affirmative($this->settings, 'update/unfinished');
2177 - if ($resume) :
2178 - // pick up where we left off
2179 - $processed = array_map('trim', explode("\n", $this->settings['update/processed']));
2180 - else :
2181 - // begin at the beginning
2182 - $processed = array();
2183 - endif;
2184 -
2185 - if (is_object($this->magpie)) :
2186 - $new_count = array('new' => 0, 'updated' => 0);
2187 -
2188 - # -- Update Link metadata live from feed
2189 - $channel = $this->magpie->channel;
2190 -
2191 - if (!isset($channel['id'])) :
2192 - $channel['id'] = $this->link->link_rss;
2193 - endif;
2194 -
2195 - $update = array();
2196 - if (!$this->hardcode('url') and isset($channel['link'])) :
2197 - $update[] = "link_url = '".$wpdb->escape($channel['link'])."'";
2198 - endif;
2199 -
2200 - if (!$this->hardcode('name') and isset($channel['title'])) :
2201 - $update[] = "link_name = '".$wpdb->escape($channel['title'])."'";
2202 - endif;
2203 -
2204 - if (!$this->hardcode('description')) :
2205 - if (isset($channel['tagline'])) :
2206 - $update[] = "link_description = '".$wpdb->escape($channel['tagline'])."'";
2207 - elseif (isset($channel['description'])) :
2208 - $update[] = "link_description = '".$wpdb->escape($channel['description'])."'";
2209 - endif;
2210 - endif;
2211 -
2212 - $this->settings = array_merge($this->settings, $this->flatten_array($channel));
2213 -
2214 - $this->settings['update/last'] = time(); $ttl = $this->ttl();
2215 - if (!is_null($ttl)) :
2216 - $this->settings['update/ttl'] = $ttl;
2217 - $this->settings['update/timed'] = 'feed';
2218 - else :
2219 - $this->settings['update/ttl'] = rand(30, 120); // spread over time interval for staggered updates
2220 - $this->settings['update/timed'] = 'automatically';
2221 - endif;
2222 -
2223 - if (!isset($this->settings['update/hold']) or $this->settings['update/hold']!='ping') :
2224 - $this->settings['update/hold'] = 'scheduled';
2225 - endif;
2226 -
2227 - $this->settings['update/unfinished'] = 'yes';
2228 -
2229 - $update[] = "link_notes = '".$wpdb->escape($this->settings_to_notes())."'";
2230 -
2231 - $update_set = implode(',', $update);
2232 -
2233 - // Update the properties of the link from the feed information
2234 - $result = $wpdb->query("
2235 - UPDATE $wpdb->links
2236 - SET $update_set
2237 - WHERE link_id='$this->id'
2238 - ");
2239 -
2240 - # -- Add new posts from feed and update any updated posts
2241 - $crashed = false;
2242 -
2243 - if (is_array($this->magpie->items)) :
2244 - foreach ($this->magpie->items as $item) :
2245 - $post =& new SyndicatedPost($item, $this);
2246 - if (!$resume or !in_array(trim($post->guid()), $processed)) :
2247 - $processed[] = $post->guid();
2248 - if (!$post->filtered()) :
2249 - $new = $post->store();
2250 - if ( $new !== false ) $new_count[$new]++;
2251 - endif;
2252 -
2253 - if (!is_null($crash_ts) and (time() > $crash_ts)) :
2254 - $crashed = true;
2255 - break;
2256 - endif;
2257 - endif;
2258 - endforeach;
2259 - endif;
2260 -
2261 - // Copy back any changes to feed settings made in the course of updating (e.g. new author rules)
2262 - $to_notes = $this->settings;
2263 -
2264 - $this->settings['update/processed'] = $processed;
2265 - if (!$crashed) :
2266 - $this->settings['update/unfinished'] = 'no';
2267 - endif;
2268 -
2269 - $update_set = "link_notes = '".$wpdb->escape($this->settings_to_notes())."'";
2270 -
2271 - // Update the properties of the link from the feed information
2272 - $result = $wpdb->query("
2273 - UPDATE $wpdb->links
2274 - SET $update_set
2275 - WHERE link_id='$this->id'
2276 - ");
2277 - endif;
2278 -
2279 - return $new_count;
2280 - } /* SyndicatedLink::poll() */
2281 -
2282 - function map_name_to_new_user ($name, $newuser_name) {
2283 - global $wpdb;
2284 -
2285 - if (strlen($newuser_name) > 0) :
2286 - $userdata = array();
2287 - $userdata['ID'] = NULL;
2288 -
2289 - $userdata['user_login'] = sanitize_user($newuser_name);
2290 - $userdata['user_login'] = apply_filters('pre_user_login', $userdata['user_login']);
2291 -
2292 - $userdata['user_nicename'] = sanitize_title($newuser_name);
2293 - $userdata['user_nicename'] = apply_filters('pre_user_nicename', $userdata['user_nicename']);
2294 -
2295 - $userdata['display_name'] = $wpdb->escape($newuser_name);
2296 -
2297 - $newuser_id = wp_insert_user($userdata);
2298 - if (is_numeric($newuser_id)) :
2299 - if (is_null($name)) : // Unfamiliar author
2300 - $this->settings['unfamiliar author'] = $newuser_id;
2301 - else :
2302 - $this->settings['map authors']['name'][$name] = $newuser_id;
2303 - endif;
2304 - else :
2305 - // TODO: Add some error detection and reporting
2306 - endif;
2307 - else :
2308 - // TODO: Add some error reporting
2309 - endif;
2310 - } /* SyndicatedLink::map_name_to_new_user () */
2311 -
2312 - function settings_to_notes () {
2313 - $to_notes = $this->settings;
2314 -
2315 - unset($to_notes['link/id']); // Magic setting; don't save
2316 - unset($to_notes['link/uri']); // Magic setting; don't save
2317 - unset($to_notes['link/name']); // Magic setting; don't save
2318 - unset($to_notes['hardcode categories']); // Deprecated
2319 - unset($to_notes['unfamiliar categories']); // Deprecated
2320 -
2321 - // Collapse array settings
2322 - if (isset($to_notes['update/processed']) and (is_array($to_notes['update/processed']))) :
2323 - $to_notes['update/processed'] = implode("\n", $to_notes['update/processed']);
2324 - endif;
2325 -
2326 - if (is_array($to_notes['cats'])) :
2327 - $to_notes['cats'] = implode(FEEDWORDPRESS_CAT_SEPARATOR, $to_notes['cats']);
2328 - endif;
2329 - if (is_array($to_notes['tags'])) :
2330 - $to_notes['tags'] = implode(FEEDWORDPRESS_CAT_SEPARATOR, $to_notes['tags']);
2331 - endif;
2332 -
2333 - // Collapse the author mapping rule structure back into a flat string
2334 - if (isset($to_notes['map authors'])) :
2335 - $ma = array();
2336 - foreach ($to_notes['map authors'] as $rule_type => $author_rules) :
2337 - foreach ($author_rules as $author_name => $author_action) :
2338 - $ma[] = $rule_type."\n".$author_name."\n".$author_action;
2339 - endforeach;
2340 - endforeach;
2341 - $to_notes['map authors'] = implode("\n\n", $ma);
2342 - endif;
2343 -
2344 - $notes = '';
2345 - foreach ($to_notes as $key => $value) :
2346 - $notes .= $key . ": ". addcslashes($value, "\0..\37".'\\') . "\n";
2347 - endforeach;
2348 - return $notes;
2349 - } /* SyndicatedLink::settings_to_notes () */
2350 -
2351 - function uri () {
2352 - return (is_object($this->link) ? $this->link->link_rss : NULL);
2353 - } /* SyndicatedLink::uri () */
2354 -
2355 - function homepage () {
2356 - return (isset($this->settings['feed/link']) ? $this->settings['feed/link'] : NULL);
2357 - } /* SyndicatedLink::homepage () */
2358 -
2359 - function ttl () {
2360 - if (is_object($this->magpie)) :
2361 - $channel = $this->magpie->channel;
2362 - else :
2363 - $channel = array();
2364 - endif;
2365 -
2366 - if (isset($channel['ttl'])) :
2367 - // "ttl stands for time to live. It's a number of
2368 - // minutes that indicates how long a channel can be
2369 - // cached before refreshing from the source."
2370 - // <http://blogs.law.harvard.edu/tech/rss#ltttlgtSubelementOfLtchannelgt>
2371 - $ret = $channel['ttl'];
2372 - elseif (isset($channel['sy']['updatefrequency']) or isset($channel['sy']['updateperiod'])) :
2373 - $period_minutes = array (
2374 - 'hourly' => 60, /* minutes in an hour */
2375 - 'daily' => 1440, /* minutes in a day */
2376 - 'weekly' => 10080, /* minutes in a week */
2377 - 'monthly' => 43200, /* minutes in a month */
2378 - 'yearly' => 525600, /* minutes in a year */
2379 - );
2380 -
2381 - // "sy:updatePeriod: Describes the period over which the
2382 - // channel format is updated. Acceptable values are:
2383 - // hourly, daily, weekly, monthly, yearly. If omitted,
2384 - // daily is assumed." <http://web.resource.org/rss/1.0/modules/syndication/>
2385 - if (isset($channel['sy']['updateperiod'])) : $period = $channel['sy']['updateperiod'];
2386 - else : $period = 'daily';
2387 - endif;
2388 -
2389 - // "sy:updateFrequency: Used to describe the frequency
2390 - // of updates in relation to the update period. A
2391 - // positive integer indicates how many times in that
2392 - // period the channel is updated. ... If omitted a value
2393 - // of 1 is assumed." <http://web.resource.org/rss/1.0/modules/syndication/>
2394 - if (isset($channel['sy']['updatefrequency'])) : $freq = (int) $channel['sy']['updatefrequency'];
2395 - else : $freq = 1;
2396 - endif;
2397 -
2398 - $ret = (int) ($period_minutes[$period] / $freq);
2399 - else :
2400 - $ret = NULL;
2401 - endif;
2402 - return $ret;
2403 - } /* SyndicatedLink::ttl() */
2404 -
2405 - // SyndicatedLink::flatten_array (): flatten an array. Useful for
2406 - // hierarchical and namespaced elements.
2407 - //
2408 - // Given an array which may contain array or object elements in it,
2409 - // return a "flattened" array: a one-dimensional array of scalars
2410 - // containing each of the scalar elements contained within the array
2411 - // structure. Thus, for example, if $a['b']['c']['d'] == 'e', then the
2412 - // returned array for FeedWordPress::flatten_array($a) will contain a key
2413 - // $a['feed/b/c/d'] with value 'e'.
2414 - function flatten_array ($arr, $prefix = 'feed/', $separator = '/') {
2415 - $ret = array ();
2416 - if (is_array($arr)) :
2417 - foreach ($arr as $key => $value) :
2418 - if (is_scalar($value)) :
2419 - $ret[$prefix.$key] = $value;
2420 - else :
2421 - $ret = array_merge($ret, $this->flatten_array($value, $prefix.$key.$separator, $separator));
2422 - endif;
2423 - endforeach;
2424 - endif;
2425 - return $ret;
2426 - } /* SyndicatedLink::flatten_array () */
2427 -
2428 - function hardcode ($what) {
2429 - $default = get_option("feedwordpress_hardcode_$what");
2430 - if ( $default === 'yes' ) :
2431 - // If the default is to hardcode, then we want the
2432 - // negation of negative(): TRUE by default and FALSE if
2433 - // the setting is explicitly "no"
2434 - $ret = !FeedWordPress::negative($this->settings, "hardcode $what");
2435 - else :
2436 - // If the default is NOT to hardcode, then we want
2437 - // affirmative(): FALSE by default and TRUE if the
2438 - // setting is explicitly "yes"
2439 - $ret = FeedWordPress::affirmative($this->settings, "hardcode $what");
2440 - endif;
2441 - return $ret;
2442 - } /* SyndicatedLink::hardcode () */
2443 -
2444 - function syndicated_status ($what, $default) {
2445 - global $wpdb;
2446 -
2447 - $ret = get_option("feedwordpress_syndicated_{$what}_status");
2448 - if ( isset($this->settings["$what status"]) ) :
2449 - $ret = $this->settings["$what status"];
2450 - elseif (!$ret) :
2451 - $ret = $default;
2452 - endif;
2453 - return $wpdb->escape(trim(strtolower($ret)));
2454 - } /* SyndicatedLink:syndicated_status () */
2455 -} // class SyndicatedLink
2456 -
2457 1520 ################################################################################
2458 1521 ## XML-RPC HOOKS: accept XML-RPC update pings from Contributors ################
2459 1522 ################################################################################
2460 1523
@@ -2463,9 +1526,9 @@
2463 1526 return $args;
2464 1527 }
2465 1528
2466 1529 function feedwordpress_pong ($args) {
2467 - $feedwordpress =& new FeedWordPress;
1530 + $feedwordpress = new FeedWordPress;
2468 1531 $delta = @$feedwordpress->update($args[1]);
2469 1532 if (is_null($delta)):
2470 1533 return array('flerror' => true, 'message' => "Sorry. I don't syndicate <$args[1]>.");
2471 1534 else:
@@ -2476,346 +1539,9 @@
2476 1539 return array('flerror' => false, 'message' => "Thanks for the ping.".implode(' and', $mesg));
2477 1540 endif;
2478 1541 }
2479 1542
2480 -################################################################################
2481 -## class FeedFinder: find likely feeds using autodetection and/or guesswork ####
2482 -################################################################################
2483 -
2484 -class FeedFinder {
2485 - var $uri = NULL;
2486 - var $_cache_uri = NULL;
2487 -
2488 - var $verify = FALSE;
2489 -
2490 - var $_data = NULL;
2491 - var $_head = NULL;
2492 -
2493 - # -- Recognition patterns
2494 - var $_feed_types = array(
2495 - 'application/rss+xml',
2496 - 'text/xml',
2497 - 'application/atom+xml',
2498 - 'application/x.atom+xml',
2499 - 'application/x-atom+xml'
2500 - );
2501 - var $_feed_markers = array('\\<feed', '\\<rss', 'xmlns="http://purl.org/rss/1.0');
2502 - var $_html_markers = array('\\<html');
2503 - var $_obvious_feed_url = array('[./]rss', '[./]rdf', '[./]atom', '[./]feed', '\.xml');
2504 - var $_maybe_feed_url = array ('rss', 'rdf', 'atom', 'feed', 'xml');
2505 -
2506 - function FeedFinder ($uri = NULL, $verify = TRUE) {
2507 - $this->uri = $uri; $this->verify = $verify;
2508 - } /* FeedFinder::FeedFinder () */
2509 -
2510 - function find ($uri = NULL) {
2511 - $ret = array ();
2512 - if (!is_null($this->data($uri))) {
2513 - if ($this->is_feed($uri)) {
2514 - $ret = array($this->uri);
2515 - } else {
2516 - // Assume that we have HTML or XHTML (even if we don't, who's it gonna hurt?)
2517 - // Autodiscovery is the preferred method
2518 - $href = $this->_link_rel_feeds();
2519 -
2520 - // ... but we'll also take the little orange buttons
2521 - $href = array_merge($href, $this->_a_href_feeds(TRUE));
2522 -
2523 - // If all that failed, look harder
2524 - if (count($href) == 0) $href = $this->_a_href_feeds(FALSE);
2525 -
2526 - // Verify feeds and resolve relative URIs
2527 - foreach ($href as $u) {
2528 - $the_uri = Relative_URI::resolve($u, $this->uri);
2529 - if ($this->verify) {
2530 - $feed =& new FeedFinder($the_uri);
2531 - if ($feed->is_feed()) $ret[] = $the_uri;
2532 - $feed = NULL;
2533 - } else {
2534 - $ret[] = $the_uri;
2535 - }
2536 - } /* foreach */
2537 - } /* if */
2538 - } /* if */
2539 - return array_unique($ret);
2540 - } /* FeedFinder::find () */
2541 -
2542 - function data ($uri = NULL) {
2543 - $this->_get($uri);
2544 - return $this->_data;
2545 - }
2546 -
2547 - function is_feed ($uri = NULL) {
2548 - $data = $this->data($uri);
2549 -
2550 - return (
2551 - preg_match (
2552 - "\007(".implode('|',$this->_feed_markers).")\007i",
2553 - $data
2554 - ) and !preg_match (
2555 - "\007(".implode('|',$this->_html_markers).")\007i",
2556 - $data
2557 - )
2558 - );
2559 - } /* FeedFinder::is_feed () */
2560 -
2561 - # --- Private methods ---
2562 - function _get ($uri = NULL) {
2563 - if ($uri) $this->uri = $uri;
2564 -
2565 - // Is the result not yet cached?
2566 - if ($this->_cache_uri !== $this->uri) :
2567 - // Snoopy is an HTTP client in PHP
2568 - $client = new Snoopy();
2569 -
2570 - // Prepare headers and internal settings
2571 - $client->rawheaders['Connection'] = 'close';
2572 - $client->accept = 'application/atom+xml application/rdf+xml application/rss+xml application/xml text/html */*';
2573 - $client->agent = 'feedfinder/1.2 (compatible; PHP FeedFinder) +http://projects.radgeek.com/feedwordpress';
2574 - $client->read_timeout = 25;
2575 -
2576 - // Fetch the HTML or feed
2577 - @$client->fetch($this->uri);
2578 - $this->_data = $client->results;
2579 -
2580 - // Kilroy was here
2581 - $this->_cache_uri = $this->uri;
2582 - endif;
2583 - } /* FeedFinder::_get () */
2584 -
2585 - function _link_rel_feeds () {
2586 - $links = $this->_tags('link');
2587 - $link_count = count($links);
2588 -
2589 - // now figure out which one points to the RSS file
2590 - $href = array ();
2591 - for ($n=0; $n<$link_count; $n++) {
2592 - if (strtolower($links[$n]['rel']) == 'alternate') {
2593 - if (in_array(strtolower($links[$n]['type']), $this->_feed_types)) {
2594 - $href[] = $links[$n]['href'];
2595 - } /* if */
2596 - } /* if */
2597 - } /* for */
2598 - return $href;
2599 - }
2600 -
2601 - function _a_href_feeds ($obvious = TRUE) {
2602 - $pattern = ($obvious ? $this->_obvious_feed_url : $this->_maybe_feed_url);
2603 -
2604 - $links = $this->_tags('a');
2605 - $link_count = count($links);
2606 -
2607 - // now figure out which one points to the RSS file
2608 - $href = array ();
2609 - for ($n=0; $n<$link_count; $n++) {
2610 - if (preg_match("\007(".implode('|',$pattern).")\007i", $links[$n]['href'])) {
2611 - $href[] = $links[$n]['href'];
2612 - } /* if */
2613 - } /* for */
2614 - return $href;
2615 - }
2616 -
2617 - function _tags ($tag) {
2618 - $html = $this->data();
2619 -
2620 - // search through the HTML, save all <link> tags
2621 - // and store each link's attributes in an associative array
2622 - preg_match_all('/<'.$tag.'\s+(.*?)\s*\/?>/si', $html, $matches);
2623 - $links = $matches[1];
2624 - $ret = array();
2625 - $link_count = count($links);
2626 - for ($n=0; $n<$link_count; $n++) {
2627 - $attributes = preg_split('/\s+/s', $links[$n]);
2628 - foreach($attributes as $attribute) {
2629 - $att = preg_split('/\s*=\s*/s', $attribute, 2);
2630 - if (isset($att[1])) {
2631 - $att[1] = preg_replace('/([\'"]?)(.*)\1/', '$2', $att[1]);
2632 - $final_link[strtolower($att[0])] = $att[1];
2633 - } /* if */
2634 - } /* foreach */
2635 - $ret[$n] = $final_link;
2636 - } /* for */
2637 - return $ret;
2638 - }
2639 -} /* class FeedFinder */
2640 -
2641 -# Relative URI static class: PHP class for resolving relative URLs
2642 -#
2643 -# This class is derived (under the terms of the GPL) from URL Class 0.3 by
2644 -# Keyvan Minoukadeh <keyvan@k1m.com>, which is great but more than we need
2645 -# for FeedWordPress's purposes. The class has been stripped down to a single
2646 -# public method: Relative_URI::resolve($url, $base), which resolves the URI in
2647 -# $url relative to the URI in $base
2648 -#
2649 -# The upgraded MagpieRSS also uses this class. So if we have it loaded
2650 -# in, don't load it again.
2651 -if (!class_exists('Relative_URI')) {
2652 -
2653 - class Relative_URI
2654 - {
2655 - // Resolve relative URI in $url against the base URI in $base. If $base
2656 - // is not supplied, then we use the REQUEST_URI of this script.
2657 - //
2658 - // I'm hoping this method reflects RFC 2396 Section 5.2
2659 - function resolve ($url, $base = NULL)
2660 - {
2661 - if (is_null($base)):
2662 - $base = 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
2663 - endif;
2664 -
2665 - $base = Relative_URI::_encode(trim($base));
2666 - $uri_parts = Relative_URI::_parse_url($base);
2667 -
2668 - $url = Relative_URI::_encode(trim($url));
2669 - $parts = Relative_URI::_parse_url($url);
2670 -
2671 - $uri_parts['fragment'] = (isset($parts['fragment']) ? $parts['fragment'] : null);
2672 - $uri_parts['query'] = (isset($parts['query']) ? $parts['query'] : null);
2673 -
2674 - // if path is empty, and scheme, host, and query are undefined,
2675 - // the URL is referring the base URL
2676 -
2677 - if (($parts['path'] == '') && !isset($parts['scheme']) && !isset($parts['host']) && !isset($parts['query'])) {
2678 - // If the URI is empty or only a fragment, return the base URI
2679 - return $base . (isset($parts['fragment']) ? '#'.$parts['fragment'] : '');
2680 - } elseif (isset($parts['scheme'])) {
2681 - // If the scheme is set, then the URI is absolute.
2682 - return $url;
2683 - } elseif (isset($parts['host'])) {
2684 - $uri_parts['host'] = $parts['host'];
2685 - $uri_parts['path'] = $parts['path'];
2686 - } else {
2687 - // We have a relative path but not a host.
2688 -
2689 - // start ugly fix:
2690 - // prepend slash to path if base host is set, base path is not set, and url path is not absolute
2691 - if ($uri_parts['host'] && ($uri_parts['path'] == '')
2692 - && (strlen($parts['path']) > 0)
2693 - && (substr($parts['path'], 0, 1) != '/')) {
2694 - $parts['path'] = '/'.$parts['path'];
2695 - } // end ugly fix
2696 -
2697 - if (substr($parts['path'], 0, 1) == '/') {
2698 - $uri_parts['path'] = $parts['path'];
2699 - } else {
2700 - // copy base path excluding any characters after the last (right-most) slash character
2701 - $buffer = substr($uri_parts['path'], 0, (int)strrpos($uri_parts['path'], '/')+1);
2702 - // append relative path
2703 - $buffer .= $parts['path'];
2704 - // remove "./" where "." is a complete path segment.
2705 - $buffer = str_replace('/./', '/', $buffer);
2706 - if (substr($buffer, 0, 2) == './') {
2707 - $buffer = substr($buffer, 2);
2708 - }
2709 - // if buffer ends with "." as a complete path segment, remove it
2710 - if (substr($buffer, -2) == '/.') {
2711 - $buffer = substr($buffer, 0, -1);
2712 - }
2713 - // remove "<segment>/../" where <segment> is a complete path segment not equal to ".."
2714 - $search_finished = false;
2715 - $segment = explode('/', $buffer);
2716 - while (!$search_finished) {
2717 - for ($x=0; $x+1 < count($segment);) {
2718 - if (($segment[$x] != '') && ($segment[$x] != '..') && ($segment[$x+1] == '..')) {
2719 - if ($x+2 == count($segment)) $segment[] = '';
2720 - unset($segment[$x], $segment[$x+1]);
2721 - $segment = array_values($segment);
2722 - continue 2;
2723 - } else {
2724 - $x++;
2725 - }
2726 - }
2727 - $search_finished = true;
2728 - }
2729 - $buffer = (count($segment) == 1) ? '/' : implode('/', $segment);
2730 - $uri_parts['path'] = $buffer;
2731 -
2732 - }
2733 - }
2734 -
2735 - // If we've gotten to this point, we can try to put the pieces
2736 - // back together.
2737 - $ret = '';
2738 - if (isset($uri_parts['scheme'])) $ret .= $uri_parts['scheme'].':';
2739 - if (isset($uri_parts['user'])) {
2740 - $ret .= $uri_parts['user'];
2741 - if (isset($uri_parts['pass'])) $ret .= ':'.$uri_parts['parts'];
2742 - $ret .= '@';
2743 - }
2744 - if (isset($uri_parts['host'])) {
2745 - $ret .= '//'.$uri_parts['host'];
2746 - if (isset($uri_parts['port'])) $ret .= ':'.$uri_parts['port'];
2747 - }
2748 - $ret .= $uri_parts['path'];
2749 - if (isset($uri_parts['query'])) $ret .= '?'.$uri_parts['query'];
2750 - if (isset($uri_parts['fragment'])) $ret .= '#'.$uri_parts['fragment'];
2751 -
2752 - return $ret;
2753 - }
2754 -
2755 - /**
2756 - * Parse URL
2757 - *
2758 - * Regular expression grabbed from RFC 2396 Appendix B.
2759 - * This is a replacement for PHPs builtin parse_url().
2760 - * @param string $url
2761 - * @access private
2762 - * @return array
2763 - */
2764 - function _parse_url($url)
2765 - {
2766 - // I'm using this pattern instead of parse_url() as there's a few strings where parse_url()
2767 - // generates a warning.
2768 - if (preg_match('!^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?!', $url, $match)) {
2769 - $parts = array();
2770 - if ($match[1] != '') $parts['scheme'] = $match[2];
2771 - if ($match[3] != '') $parts['auth'] = $match[4];
2772 - // parse auth
2773 - if (isset($parts['auth'])) {
2774 - // store user info
2775 - if (($at_pos = strpos($parts['auth'], '@')) !== false) {
2776 - $userinfo = explode(':', substr($parts['auth'], 0, $at_pos), 2);
2777 - $parts['user'] = $userinfo[0];
2778 - if (isset($userinfo[1])) $parts['pass'] = $userinfo[1];
2779 - $parts['auth'] = substr($parts['auth'], $at_pos+1);
2780 - }
2781 - // get port number
2782 - if ($port_pos = strrpos($parts['auth'], ':')) {
2783 - $parts['host'] = substr($parts['auth'], 0, $port_pos);
2784 - $parts['port'] = (int)substr($parts['auth'], $port_pos+1);
2785 - if ($parts['port'] < 1) $parts['port'] = null;
2786 - } else {
2787 - $parts['host'] = $parts['auth'];
2788 - }
2789 - }
2790 - unset($parts['auth']);
2791 - $parts['path'] = $match[5];
2792 - if (isset($match[6]) && ($match[6] != '')) $parts['query'] = $match[7];
2793 - if (isset($match[8]) && ($match[8] != '')) $parts['fragment'] = $match[9];
2794 - return $parts;
2795 - }
2796 - // shouldn't reach here
2797 - return array('path'=>'');
2798 - }
2799 -
2800 - function _encode($string)
2801 - {
2802 - static $replace = array();
2803 - if (!count($replace)) {
2804 - $find = array(32, 34, 60, 62, 123, 124, 125, 91, 92, 93, 94, 96, 127);
2805 - $find = array_merge(range(0, 31), $find);
2806 - $find = array_map('chr', $find);
2807 - foreach ($find as $char) {
2808 - $replace[$char] = '%'.bin2hex($char);
2809 - }
2810 - }
2811 - // escape control characters and a few other characters
2812 - $encoded = strtr($string, $replace);
2813 - // remove any character outside the hex range: 21 - 7E (see www.asciitable.com)
2814 - return preg_replace('/[^\x21-\x7e]/', '', $encoded);
2815 - }
2816 - } // class Relative_URI
2817 -}
1543 +require_once(dirname(__FILE__) . '/relative_uri.class.php');
2818 1544
2819 1545 // take your best guess at the realname and e-mail, given a string
2820 1546 define('FWP_REGEX_EMAIL_ADDY', '([^@"(<\s]+@[^"@(<\s]+\.[^"@(<\s]+)');
2821 1547 define('FWP_REGEX_EMAIL_NAME', '("([^"]*)"|([^"<(]+\S))');