PluginProbe
FeedWordPress / 2009.0613
FeedWordPress v2009.0613
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 +1373 -20 2009.0707 → 2009.0613 View file →
@@ -2,9 +2,9 @@
2 2 /*
3 3 Plugin Name: FeedWordPress
4 4 Plugin URI: http://projects.radgeek.com/feedwordpress
5 5 Description: simple and flexible Atom/RSS syndication for WordPress
6 -Version: 2009.0707
6 +Version: 2009.0613
7 7 Author: Charles Johnson
8 8 Author URI: http://radgeek.com/
9 9 License: GPL
10 10 */
@@ -27,9 +27,9 @@
27 27 # or use a cron job.
28 28
29 29 # -- Don't change these unless you know what you're doing...
30 30
31 -define ('FEEDWORDPRESS_VERSION', '2009.0707');
31 +define ('FEEDWORDPRESS_VERSION', '2009.0612');
32 32 define ('FEEDWORDPRESS_AUTHOR_CONTACT', 'http://radgeek.com/contact');
33 33 define ('DEFAULT_SYNDICATION_CATEGORY', 'Contributors');
34 34
35 35 $feedwordpress_debug = get_option('feedwordpress_debug');
@@ -51,9 +51,8 @@
51 51 define ('FWP_SCHEMA_23', 5495); // Database schema # for WP 2.3
52 52 define ('FWP_SCHEMA_25', 7558); // Database schema # for WP 2.5
53 53 define ('FWP_SCHEMA_26', 8201); // Database schema # for WP 2.6
54 54 define ('FWP_SCHEMA_27', 9872); // Database schema # for WP 2.7
55 -define ('FWP_SCHEMA_28', 11548); // Database schema # for WP 2.8
56 55
57 56 if (FEEDWORDPRESS_DEBUG) :
58 57 // Help us to pick out errors, if any.
59 58 ini_set('error_reporting', E_ALL & ~E_NOTICE);
@@ -507,9 +506,9 @@
507 506 <?php
508 507 endif;
509 508 } /* function fwp_check_debug () */
510 509
511 -define('EXPECTED_MAGPIE_VERSION', '2009.0618');
510 +define('EXPECTED_MAGPIE_VERSION', '2009.0613');
512 511 function fwp_check_magpie () {
513 512 if (isset($_REQUEST['feedwordpress_magpie_fix'])) :
514 513 if ($_REQUEST['feedwordpress_magpie_fix']=='ignored') :
515 514 ?>
@@ -1004,9 +1003,12 @@
1004 1003 $ret = false; // innocent until proven guilty
1005 1004 if (!$fwp_db_version or $fwp_db_version < FEEDWORDPRESS_VERSION) :
1006 1005 // This is an older version or a fresh install. Does it
1007 1006 // require a database upgrade or database initialization?
1008 - if ($fwp_db_version <= 0.96) :
1007 + if ($fwp_db_version > 0.96) :
1008 + // No. Just brand it with the new version.
1009 + update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1010 + else :
1009 1011 // Yes. Check to see whether this is a fresh install or an upgrade.
1010 1012 $syn = $wpdb->get_col("
1011 1013 SELECT post_id
1012 1014 FROM $wpdb->postmeta
@@ -1016,21 +1018,8 @@
1016 1018 $ret = true;
1017 1019 else : // fresh install; brand it as ours
1018 1020 update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1019 1021 endif;
1020 - elseif ($fwp_db_version < 2009.0707) :
1021 - // We need to clear out any busted AJAX crap
1022 - if (fwp_test_wp_version(FWP_SCHEMA_HAS_USERMETA)) :
1023 - $wpdb->query("
1024 - DELETE FROM $wpdb->usermeta
1025 - WHERE LOCATE('feedwordpress', meta_key)
1026 - AND LOCATE('box', meta_key);
1027 - ");
1028 - endif;
1029 - update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1030 - else :
1031 - // No. Just brand it with the new version.
1032 - update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1033 1022 endif;
1034 1023 endif;
1035 1024 return $ret;
1036 1025 }
@@ -1148,9 +1137,1201 @@
1148 1137 endif;
1149 1138 }
1150 1139 } // class FeedWordPress
1151 1140
1152 -require_once(dirname(__FILE__) . '/syndicatedpost.class.php');
1141 +class SyndicatedPost {
1142 + var $item = null;
1143 +
1144 + var $link = null;
1145 + var $feed = null;
1146 + var $feedmeta = null;
1147 +
1148 + var $post = array ();
1149 +
1150 + var $_freshness = null;
1151 + var $_wp_id = null;
1152 +
1153 + function SyndicatedPost ($item, $link) {
1154 + global $wpdb;
1155 +
1156 + $this->link = $link;
1157 + $feedmeta = $link->settings;
1158 + $feed = $link->magpie;
1159 +
1160 + # This is ugly as all hell. I'd like to use apply_filters()'s
1161 + # alleged support for a variable argument count, but this seems
1162 + # to have been broken in WordPress 1.5. It'll be fixed somehow
1163 + # in WP 1.5.1, but I'm aiming at WP 1.5 compatibility across
1164 + # the board here.
1165 + #
1166 + # Cf.: <http://mosquito.wordpress.org/view.php?id=901>
1167 + global $fwp_channel, $fwp_feedmeta;
1168 + $fwp_channel = $feed; $fwp_feedmeta = $feedmeta;
1169 +
1170 + $this->feed = $feed;
1171 + $this->feedmeta = $feedmeta;
1172 +
1173 + $this->item = $item;
1174 + $this->item = apply_filters('syndicated_item', $this->item, $this);
1175 +
1176 + # Filters can halt further processing by returning NULL
1177 + if (is_null($this->item)) :
1178 + $this->post = NULL;
1179 + else :
1180 + # Note that nothing is run through $wpdb->escape() here.
1181 + # That's deliberate. The escaping is done at the point
1182 + # of insertion, not here, to avoid double-escaping and
1183 + # to avoid screwing with syndicated_post filters
1184 +
1185 + $this->post['post_title'] = apply_filters('syndicated_item_title', $this->item['title'], $this);
1186 +
1187 + // This just gives us an alphanumeric representation of
1188 + // the author. We will look up (or create) the numeric
1189 + // ID for the author in SyndicatedPost::add()
1190 + $this->post['named']['author'] = apply_filters('syndicated_item_author', $this->author(), $this);
1191 +
1192 + # Identify content and sanitize it.
1193 + # ---------------------------------
1194 + if (isset($this->item['atom_content'])) :
1195 + $content = $this->item['atom_content'];
1196 + elseif (isset($this->item['xhtml']['body'])) :
1197 + $content = $this->item['xhtml']['body'];
1198 + elseif (isset($this->item['xhtml']['div'])) :
1199 + $content = $this->item['xhtml']['div'];
1200 + elseif (isset($this->item['content']['encoded']) and $this->item['content']['encoded']):
1201 + $content = $this->item['content']['encoded'];
1202 + else:
1203 + $content = $this->item['description'];
1204 + endif;
1205 + $this->post['post_content'] = apply_filters('syndicated_item_content', $content, $this);
1206 +
1207 + # Identify and sanitize excerpt
1208 + $excerpt = NULL;
1209 + if ( isset($this->item['description']) and $this->item['description'] ) :
1210 + $excerpt = $this->item['description'];
1211 + elseif ( isset($content) and $content ) :
1212 + $excerpt = strip_tags($content);
1213 + if (strlen($excerpt) > 255) :
1214 + $excerpt = substr($excerpt,0,252).'...';
1215 + endif;
1216 + endif;
1217 + $excerpt = apply_filters('syndicated_item_excerpt', $excerpt, $this);
1218 +
1219 + if (!is_null($excerpt)):
1220 + $this->post['post_excerpt'] = $excerpt;
1221 + endif;
1222 +
1223 + // This is unnecessary if we use wp_insert_post
1224 + if (!$this->use_api('wp_insert_post')) :
1225 + $this->post['post_name'] = sanitize_title($this->post['post_title']);
1226 + endif;
1227 +
1228 + $this->post['epoch']['issued'] = apply_filters('syndicated_item_published', $this->published(), $this);
1229 + $this->post['epoch']['created'] = apply_filters('syndicated_item_created', $this->created(), $this);
1230 + $this->post['epoch']['modified'] = apply_filters('syndicated_item_updated', $this->updated(), $this);
1231 +
1232 + // Dealing with timestamps in WordPress is so fucking fucked.
1233 + $offset = (int) get_option('gmt_offset') * 60 * 60;
1234 + $this->post['post_date'] = gmdate('Y-m-d H:i:s', $this->published() + $offset);
1235 + $this->post['post_modified'] = gmdate('Y-m-d H:i:s', $this->updated() + $offset);
1236 + $this->post['post_date_gmt'] = gmdate('Y-m-d H:i:s', $this->published());
1237 + $this->post['post_modified_gmt'] = gmdate('Y-m-d H:i:s', $this->updated());
1238 +
1239 + // Use feed-level preferences or the global default.
1240 + $this->post['post_status'] = $this->link->syndicated_status('post', 'publish');
1241 + $this->post['comment_status'] = $this->link->syndicated_status('comment', 'closed');
1242 + $this->post['ping_status'] = $this->link->syndicated_status('ping', 'closed');
1243 +
1244 + // Unique ID (hopefully a unique tag: URI); failing that, the permalink
1245 + $this->post['guid'] = apply_filters('syndicated_item_guid', $this->guid(), $this);
1246 +
1247 + // User-supplied custom settings to apply to each post. Do first so that FWP-generated custom settings will overwrite if necessary; thus preventing any munging
1248 + $default_custom_settings = get_option('feedwordpress_custom_settings');
1249 + if ($default_custom_settings) :
1250 + $default_custom_settings = unserialize($default_custom_settings);
1251 + endif;
1252 + if (!is_array($default_custom_settings)) :
1253 + $default_custom_settings = array();
1254 + endif;
1255 +
1256 + $custom_settings = $this->link->settings['postmeta'];
1257 + if ($custom_settings) :
1258 + $custom_settings = unserialize($custom_settings);
1259 + endif;
1260 + if (!is_array($custom_settings)) :
1261 + $custom_settings = array();
1262 + endif;
1263 + $this->post['meta'] = array_merge($default_custom_settings, $custom_settings);
1264 +
1265 + // RSS 2.0 / Atom 1.0 enclosure support
1266 + if ( isset($this->item['enclosure#']) ) :
1267 + for ($i = 1; $i <= $this->item['enclosure#']; $i++) :
1268 + $eid = (($i > 1) ? "#{$id}" : "");
1269 + $this->post['meta']['enclosure'][] =
1270 + apply_filters('syndicated_item_enclosure_url', $this->item["enclosure{$eid}@url"], $this)."\n".
1271 + apply_filters('syndicated_item_enclosure_length', $this->item["enclosure{$eid}@length"], $this)."\n".
1272 + apply_filters('syndicated_item_enclosure_type', $this->item["enclosure{$eid}@type"], $this);
1273 + endfor;
1274 + endif;
1275 +
1276 + // In case you want to point back to the blog this was syndicated from
1277 + if (isset($this->feed->channel['title'])) :
1278 + $this->post['meta']['syndication_source'] = apply_filters('syndicated_item_source_title', $this->feed->channel['title'], $this);
1279 + endif;
1280 +
1281 + if (isset($this->feed->channel['link'])) :
1282 + $this->post['meta']['syndication_source_uri'] = apply_filters('syndicated_item_source_link', $this->feed->channel['link'], $this);
1283 + endif;
1284 +
1285 + // Make use of atom:source data, if present in an aggregated feed
1286 + if (isset($this->item['source_title'])) :
1287 + $this->post['meta']['syndication_source_original'] = $this->item['source_title'];
1288 + endif;
1289 +
1290 + if (isset($this->item['source_link'])) :
1291 + $this->post['meta']['syndication_source_uri_original'] = $this->item['source_link'];
1292 + endif;
1293 +
1294 + if (isset($this->item['source_id'])) :
1295 + $this->post['meta']['syndication_source_id_original'] = $this->item['source_id'];
1296 + endif;
1297 +
1298 + // Store information on human-readable and machine-readable comment URIs
1299 + if (isset($this->item['comments'])) :
1300 + $this->post['meta']['rss:comments'] = apply_filters('syndicated_item_comments', $this->item['comments']);
1301 + endif;
1302 + if (isset($this->item['wfw']['commentrss'])) :
1303 + $this->post['meta']['wfw:commentRSS'] = apply_filters('syndicated_item_commentrss', $this->item['wfw']['commentrss']);
1304 + endif;
1305 +
1306 + // Store information to identify the feed that this came from
1307 + $this->post['meta']['syndication_feed'] = $this->feedmeta['link/uri'];
1308 + $this->post['meta']['syndication_feed_id'] = $this->feedmeta['link/id'];
1309 +
1310 + if (isset($this->item['source_link_self'])) :
1311 + $this->post['meta']['syndication_feed_original'] = $this->item['source_link_self'];
1312 + endif;
1313 +
1314 + // In case you want to know the external permalink...
1315 + $this->post['meta']['syndication_permalink'] = apply_filters('syndicated_item_link', $this->item['link']);
1316 +
1317 + // Store a hash of the post content for checking whether something needs to be updated
1318 + $this->post['meta']['syndication_item_hash'] = $this->update_hash();
1319 +
1320 + // Feed-by-feed options for author and category creation
1321 + $this->post['named']['unfamiliar']['author'] = $this->feedmeta['unfamiliar author'];
1322 + $this->post['named']['unfamiliar']['category'] = $this->feedmeta['unfamiliar category'];
1323 +
1324 + // Categories: start with default categories, if any
1325 + $fc = get_option("feedwordpress_syndication_cats");
1326 + if ($fc) :
1327 + $this->post['named']['preset/category'] = explode("\n", $fc);
1328 + else :
1329 + $this->post['named']['preset/category'] = array();
1330 + endif;
1331 +
1332 + if (is_array($this->feedmeta['cats'])) :
1333 + $this->post['named']['preset/category'] = array_merge($this->post['named']['preset/category'], $this->feedmeta['cats']);
1334 + endif;
1335 +
1336 + // Now add categories from the post, if we have 'em
1337 + $this->post['named']['category'] = array();
1338 + if ( isset($this->item['category#']) ) :
1339 + for ($i = 1; $i <= $this->item['category#']; $i++) :
1340 + $cat_idx = (($i > 1) ? "#{$i}" : "");
1341 + $cat = $this->item["category{$cat_idx}"];
1342 +
1343 + if ( isset($this->feedmeta['cat_split']) and strlen($this->feedmeta['cat_split']) > 0) :
1344 + $pcre = "\007".$this->feedmeta['cat_split']."\007";
1345 + $this->post['named']['category'] = array_merge($this->post['named']['category'], preg_split($pcre, $cat, -1 /*=no limit*/, PREG_SPLIT_NO_EMPTY));
1346 + else :
1347 + $this->post['named']['category'][] = $cat;
1348 + endif;
1349 + endfor;
1350 + endif;
1351 + $this->post['named']['category'] = apply_filters('syndicated_item_categories', $this->post['named']['category'], $this);
1352 +
1353 + // Tags: start with default tags, if any
1354 + $ft = get_option("feedwordpress_syndication_tags");
1355 + if ($ft) :
1356 + $this->post['tags_input'] = explode(FEEDWORDPRESS_CAT_SEPARATOR, $ft);
1357 + else :
1358 + $this->post['tags_input'] = array();
1359 + endif;
1360 +
1361 + if (is_array($this->feedmeta['tags'])) :
1362 + $this->post['tags_input'] = array_merge($this->post['tags_input'], $this->feedmeta['tags']);
1363 + endif;
1364 +
1365 + endif;
1366 + } // SyndicatedPost::SyndicatedPost()
1367 +
1368 + function filtered () {
1369 + return is_null($this->post);
1370 + }
1371 +
1372 + function freshness () {
1373 + global $wpdb;
1374 +
1375 + if ($this->filtered()) : // This should never happen.
1376 + FeedWordPress::critical_bug('SyndicatedPost', $this, __LINE__);
1377 + endif;
1378 +
1379 + if (is_null($this->_freshness)) :
1380 + $guid = $wpdb->escape($this->guid());
1381 +
1382 + $result = $wpdb->get_row("
1383 + SELECT id, guid, post_modified_gmt
1384 + FROM $wpdb->posts WHERE guid='$guid'
1385 + ");
1386 +
1387 + if (!$result) :
1388 + $this->_freshness = 2; // New content
1389 + else:
1390 + $stored_update_hashes = get_post_custom_values('syndication_item_hash', $result->id);
1391 + if (count($stored_update_hashes) > 0) :
1392 + $stored_update_hash = $stored_update_hashes[0];
1393 + $update_hash_changed = ($stored_update_hash != $this->update_hash());
1394 + else :
1395 + $update_hash_changed = false;
1396 + endif;
1397 +
1398 + preg_match('/([0-9]+)-([0-9]+)-([0-9]+) ([0-9]+):([0-9]+):([0-9]+)/', $result->post_modified_gmt, $backref);
1399 +
1400 + $last_rev_ts = gmmktime($backref[4], $backref[5], $backref[6], $backref[2], $backref[3], $backref[1]);
1401 + $updated_ts = $this->updated(/*fallback=*/ true, /*default=*/ NULL);
1402 + $updated = ((
1403 + !is_null($updated_ts)
1404 + and ($updated_ts > $last_rev_ts)
1405 + ) or $update_hash_changed);
1406 +
1407 + if ($updated) :
1408 + $this->_freshness = 1; // Updated content
1409 + $this->_wp_id = $result->id;
1410 + else :
1411 + $this->_freshness = 0; // Same old, same old
1412 + $this->_wp_id = $result->id;
1413 + endif;
1414 + endif;
1415 + endif;
1416 + return $this->_freshness;
1417 + }
1418 +
1419 + function wp_id () {
1420 + if ($this->filtered()) : // This should never happen.
1421 + FeedWordPress::critical_bug('SyndicatedPost', $this, __LINE__);
1422 + endif;
1423 +
1424 + if (is_null($this->_wp_id) and is_null($this->_freshness)) :
1425 + $fresh = $this->freshness(); // sets WP DB id in the process
1426 + endif;
1427 + return $this->_wp_id;
1428 + }
1429 +
1430 + function store () {
1431 + global $wpdb;
1432 +
1433 + if ($this->filtered()) : // This should never happen.
1434 + FeedWordPress::critical_bug('SyndicatedPost', $this, __LINE__);
1435 + endif;
1436 +
1437 + $freshness = $this->freshness();
1438 + if ($freshness > 0) :
1439 + # -- Look up, or create, numeric ID for author
1440 + $this->post['post_author'] = $this->author_id (
1441 + FeedWordPress::on_unfamiliar('author', $this->post['named']['unfamiliar']['author'])
1442 + );
1443 +
1444 + if (is_null($this->post['post_author'])) :
1445 + $this->post = NULL;
1446 + endif;
1447 + endif;
1448 +
1449 + if (!$this->filtered() and $freshness > 0) :
1450 + # -- Look up, or create, numeric ID for categories
1451 + list($pcats, $ptags) = $this->category_ids (
1452 + $this->post['named']['category'],
1453 + FeedWordPress::on_unfamiliar('category', $this->post['named']['unfamiliar']['category']),
1454 + /*tags_too=*/ true
1455 + );
1456 +
1457 + $this->post['post_category'] = $pcats;
1458 + $this->post['tags_input'] = array_merge($this->post['tags_input'], $ptags);
1459 +
1460 + if (is_null($this->post['post_category'])) :
1461 + // filter mode on, no matching categories; drop the post
1462 + $this->post = NULL;
1463 + else :
1464 + // filter mode off or at least one match; now add on the feed and global presets
1465 + $this->post['post_category'] = array_merge (
1466 + $this->post['post_category'],
1467 + $this->category_ids (
1468 + $this->post['named']['preset/category'],
1469 + 'default'
1470 + )
1471 + );
1472 +
1473 + if (count($this->post['post_category']) < 1) :
1474 + $this->post['post_category'][] = 1; // Default to category 1 ("Uncategorized" / "General") if nothing else
1475 + endif;
1476 + endif;
1477 + endif;
1478 +
1479 + if (!$this->filtered() and $freshness > 0) :
1480 + unset($this->post['named']);
1481 + $this->post = apply_filters('syndicated_post', $this->post, $this);
1482 + endif;
1483 +
1484 + if (!$this->filtered() and $freshness == 2) :
1485 + // The item has not yet been added. So let's add it.
1486 + $this->insert_new();
1487 + $this->add_rss_meta();
1488 + do_action('post_syndicated_item', $this->wp_id());
1489 +
1490 + $ret = 'new';
1491 + elseif (!$this->filtered() and $freshness == 1) :
1492 + $this->post['ID'] = $this->wp_id();
1493 + $this->update_existing();
1494 + $this->add_rss_meta();
1495 + do_action('update_syndicated_item', $this->wp_id());
1496 +
1497 + $ret = 'updated';
1498 + else :
1499 + $ret = false;
1500 + endif;
1501 +
1502 + return $ret;
1503 + } // function SyndicatedPost::store ()
1504 +
1505 + function insert_new () {
1506 + global $wpdb, $wp_db_version;
1507 +
1508 + $dbpost = $this->normalize_post(/*new=*/ true);
1509 + if (!is_null($dbpost)) :
1510 + if ($this->use_api('wp_insert_post')) :
1511 + $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1512 +
1513 + // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1514 + add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1515 +
1516 + // Kludge to prevent kses filters from stripping the
1517 + // content of posts when updating without a logged in
1518 + // user who has `unfiltered_html` capability.
1519 + add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1520 +
1521 + $this->_wp_id = wp_insert_post($dbpost);
1522 +
1523 + // Turn off ridiculous fucking kludges #1 and #2
1524 + remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1525 + remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1526 +
1527 + $this->validate_post_id($dbpost, array(__CLASS__, __FUNCTION__));
1528 +
1529 + // Unfortunately, as of WordPress 2.3, wp_insert_post()
1530 + // *still* offers no way to use a guid of your choice,
1531 + // and munges your post modified timestamp, too.
1532 + $result = $wpdb->query("
1533 + UPDATE $wpdb->posts
1534 + SET
1535 + guid='{$dbpost['guid']}',
1536 + post_modified='{$dbpost['post_modified']}',
1537 + post_modified_gmt='{$dbpost['post_modified_gmt']}'
1538 + WHERE ID='{$this->_wp_id}'
1539 + ");
1540 + else :
1541 + # The right way to do this is the above. But, alas,
1542 + # in earlier versions of WordPress, wp_insert_post has
1543 + # too much behavior (mainly related to pings) that can't
1544 + # be overridden. In WordPress 1.5, it's enough of a
1545 + # resource hog to make PHP segfault after inserting
1546 + # 50-100 posts. This can get pretty annoying, especially
1547 + # if you are trying to update your feeds for the first
1548 + # time.
1549 +
1550 + $result = $wpdb->query("
1551 + INSERT INTO $wpdb->posts
1552 + SET
1553 + guid = '{$dbpost['guid']}',
1554 + post_author = '{$dbpost['post_author']}',
1555 + post_date = '{$dbpost['post_date']}',
1556 + post_date_gmt = '{$dbpost['post_date_gmt']}',
1557 + post_content = '{$dbpost['post_content']}',"
1558 + .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1559 + post_title = '{$dbpost['post_title']}',
1560 + post_name = '{$dbpost['post_name']}',
1561 + post_modified = '{$dbpost['post_modified']}',
1562 + post_modified_gmt = '{$dbpost['post_modified_gmt']}',
1563 + comment_status = '{$dbpost['comment_status']}',
1564 + ping_status = '{$dbpost['ping_status']}',
1565 + post_status = '{$dbpost['post_status']}'
1566 + ");
1567 + $this->_wp_id = $wpdb->insert_id;
1568 +
1569 + $this->validate_post_id($dbpost, array(__CLASS__, __FUNCTION__));
1570 +
1571 + // WordPress 1.5.x - 2.0.x
1572 + wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1573 +
1574 + // Since we are not going through official channels, we need to
1575 + // manually tell WordPress that we've published a new post.
1576 + // We need to make sure to do this in order for FeedWordPress
1577 + // to play well with the staticize-reloaded plugin (something
1578 + // that a large aggregator website is going to *want* to be
1579 + // able to use).
1580 + do_action('publish_post', $this->_wp_id);
1581 + endif;
1582 + endif;
1583 + } /* SyndicatedPost::insert_new() */
1584 +
1585 + function update_existing () {
1586 + global $wpdb;
1587 +
1588 + // Why the fuck doesn't wp_insert_post already do this?
1589 + $dbpost = $this->normalize_post(/*new=*/ false);
1590 + if (!is_null($dbpost)) :
1591 + if ($this->use_api('wp_insert_post')) :
1592 + $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1593 +
1594 + // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1595 + add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1596 +
1597 + // Kludge to prevent kses filters from stripping the
1598 + // content of posts when updating without a logged in
1599 + // user who has `unfiltered_html` capability.
1600 + add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1601 +
1602 + // Don't munge status fields that the user may have reset manually
1603 + if (function_exists('get_post_field')) :
1604 + $doNotMunge = array('post_status', 'comment_status', 'ping_status');
1605 + foreach ($doNotMunge as $field) :
1606 + $dbpost[$field] = get_post_field($field, $this->wp_id());
1607 + endforeach;
1608 + endif;
1609 +
1610 + $this->_wp_id = wp_insert_post($dbpost);
1611 +
1612 + // Turn off ridiculous fucking kludges #1 and #2
1613 + remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1614 + remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1615 +
1616 + $this->validate_post_id($dbpost, array(__CLASS__, __FUNCTION__));
1617 +
1618 + // Unfortunately, as of WordPress 2.3, wp_insert_post()
1619 + // munges your post modified timestamp.
1620 + $result = $wpdb->query("
1621 + UPDATE $wpdb->posts
1622 + SET
1623 + post_modified='{$dbpost['post_modified']}',
1624 + post_modified_gmt='{$dbpost['post_modified_gmt']}'
1625 + WHERE ID='{$this->_wp_id}'
1626 + ");
1627 + else :
1628 +
1629 + $result = $wpdb->query("
1630 + UPDATE $wpdb->posts
1631 + SET
1632 + post_author = '{$dbpost['post_author']}',
1633 + post_content = '{$dbpost['post_content']}',"
1634 + .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1635 + post_title = '{$dbpost['post_title']}',
1636 + post_name = '{$dbpost['post_name']}',
1637 + post_modified = '{$dbpost['post_modified']}',
1638 + post_modified_gmt = '{$dbpost['post_modified_gmt']}'
1639 + WHERE guid='{$dbpost['guid']}'
1640 + ");
1641 +
1642 + // WordPress 2.1.x and up
1643 + if (function_exists('wp_set_post_categories')) :
1644 + wp_set_post_categories($this->wp_id(), $this->post['post_category']);
1645 + // WordPress 1.5.x - 2.0.x
1646 + elseif (function_exists('wp_set_post_cats')) :
1647 + wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1648 + // This should never happen.
1649 + else :
1650 + FeedWordPress::critical_bug(__CLASS__.'::'.__FUNCTION.'(): no post categorizing function', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1651 + endif;
1652 +
1653 + // Since we are not going through official channels, we need to
1654 + // manually tell WordPress that we've published a new post.
1655 + // We need to make sure to do this in order for FeedWordPress
1656 + // to play well with the staticize-reloaded plugin (something
1657 + // that a large aggregator website is going to *want* to be
1658 + // able to use).
1659 + do_action('edit_post', $this->post['ID']);
1660 + endif;
1661 + endif;
1662 + } /* SyndicatedPost::update_existing() */
1663 +
1664 + /**
1665 + * SyndicatedPost::normalize_post()
1666 + *
1667 + * @param bool $new If true, this post is to be inserted anew. If false, it is an update of an existing post.
1668 + * @return array A normalized representation of the post ready to be inserted into the database or sent to the WordPress API functions
1669 + */
1670 + function normalize_post ($new = true) {
1671 + global $wpdb;
1672 +
1673 + $out = array();
1674 +
1675 + // Why the fuck doesn't wp_insert_post already do this?
1676 + foreach ($this->post as $key => $value) :
1677 + if (is_string($value)) :
1678 + $out[$key] = $wpdb->escape($value);
1679 + else :
1680 + $out[$key] = $value;
1681 + endif;
1682 + endforeach;
1683 +
1684 + if (strlen($out['post_title'].$out['post_content'].$out['post_excerpt']) == 0) :
1685 + // FIXME: Option for filtering out empty posts
1686 + endif;
1687 + if (strlen($out['post_title'])==0) :
1688 + $offset = (int) get_option('gmt_offset') * 60 * 60;
1689 + $out['post_title'] =
1690 + $this->post['meta']['syndication_source']
1691 + .' '.gmdate('Y-m-d H:i:s', $this->published() + $offset);
1692 + // FIXME: Option for what to fill a blank title with...
1693 + endif;
1694 +
1695 + return $out;
1696 + }
1697 +
1698 + /**
1699 + * SyndicatedPost::validate_post_id()
1700 + *
1701 + * @param array $dbpost An array representing the post we attempted to insert or update
1702 + * @param mixed $ns A string or array representing the namespace (class, method) whence this method was called.
1703 + */
1704 + function validate_post_id ($dbpost, $ns) {
1705 + if (is_array($ns)) : $ns = implode('::', $ns);
1706 + else : $ns = (string) $ns; endif;
1707 +
1708 + // This should never happen.
1709 + if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1710 + FeedWordPress::critical_bug(
1711 + /*name=*/ $ns.'::_wp_id',
1712 + /*var =*/ array(
1713 + "\$this->_wp_id" => $this->_wp_id,
1714 + "\$dbpost" => $dbpost,
1715 + "\$this" => $this
1716 + ),
1717 + /*line # =*/ __LINE__
1718 + );
1719 + endif;
1720 + } /* SyndicatedPost::validate_post_id() */
1721 +
1722 + /**
1723 + * SyndicatedPost::fix_revision_meta() - Fixes the way WP 2.6+ fucks up
1724 + * meta-data (authorship, etc.) when storing revisions of an updated
1725 + * syndicated post.
1726 + *
1727 + * In their infinite wisdom, the WordPress coders have made it completely
1728 + * impossible for a plugin that uses wp_insert_post() to set certain
1729 + * meta-data (such as the author) when you store an old revision of an
1730 + * updated post. Instead, it uses the WordPress defaults (= currently
1731 + * active user ID if the process is running with a user logged in, or
1732 + * = #0 if there is no user logged in). This results in bogus authorship
1733 + * data for revisions that are syndicated from off the feed, unless we
1734 + * use a ridiculous kludge like this to end-run the munging of meta-data
1735 + * by _wp_put_post_revision.
1736 + *
1737 + * @param int $revision_id The revision ID to fix up meta-data
1738 + */
1739 + function fix_revision_meta ($revision_id) {
1740 + global $wpdb;
1741 +
1742 + $post_author = (int) $this->post['post_author'];
1743 +
1744 + $revision_id = (int) $revision_id;
1745 + $wpdb->query("
1746 + UPDATE $wpdb->posts
1747 + SET post_author={$this->post['post_author']}
1748 + WHERE post_type = 'revision' AND ID='$revision_id'
1749 + ");
1750 + } /* SyndicatedPost::fix_revision_meta () */
1751 +
1752 + /**
1753 + * SyndicatedPost::avoid_kses_munge() -- If FeedWordPress is processing
1754 + * an automatic update, that generally means that wp_insert_post() is
1755 + * being called under the user credentials of whoever is viewing the
1756 + * blog at the time -- usually meaning no user at all. But if WordPress
1757 + * gets a wp_insert_post() when current_user_can('unfiltered_html') is
1758 + * false, it will run the content of the post through a kses function
1759 + * that strips out lots of HTML tags -- notably <object> and some others.
1760 + * This causes problems for syndicating (for example) feeds that contain
1761 + * YouTube videos. It also produces an unexpected asymmetry between
1762 + * automatically-initiated updates and updates initiated manually from
1763 + * the WordPress Dashboard (which are usually initiated under the
1764 + * credentials of a logged-in admin, and so don't get run through the
1765 + * kses function). So, to avoid the whole mess, what we do here is
1766 + * just forcibly disable the kses munging for a single syndicated post,
1767 + * by restoring the contents of the `post_content` field.
1768 + *
1769 + * @param string $content The content of the post, after other filters have gotten to it
1770 + * @return string The original content of the post, before other filters had a chance to munge it.
1771 + */
1772 + function avoid_kses_munge ($content) {
1773 + global $wpdb;
1774 + return $wpdb->escape($this->post['post_content']);
1775 + }
1776 +
1777 + // SyndicatedPost::add_rss_meta: adds interesting meta-data to each entry
1778 + // using the space for custom keys. The set of keys and values to add is
1779 + // specified by the keys and values of $post['meta']. This is used to
1780 + // store anything that the WordPress user might want to access from a
1781 + // template concerning the post's original source that isn't provided
1782 + // for by standard WP meta-data (i.e., any interesting data about the
1783 + // syndicated post other than author, title, timestamp, categories, and
1784 + // guid). It's also used to hook into WordPress's support for
1785 + // enclosures.
1786 + function add_rss_meta () {
1787 + global $wpdb;
1788 + if ( is_array($this->post) and isset($this->post['meta']) and is_array($this->post['meta']) ) :
1789 + $postId = $this->wp_id();
1790 +
1791 + // Aggregated posts should NOT send out pingbacks.
1792 + // WordPress 2.1-2.2 claim you can tell them not to
1793 + // using $post_pingback, but they don't listen, so we
1794 + // make sure here.
1795 + $result = $wpdb->query("
1796 + DELETE FROM $wpdb->postmeta
1797 + WHERE post_id='$postId' AND meta_key='_pingme'
1798 + ");
1799 +
1800 + foreach ( $this->post['meta'] as $key => $values ) :
1801 +
1802 + $key = $wpdb->escape($key);
1803 +
1804 + // If this is an update, clear out the old
1805 + // values to avoid duplication.
1806 + $result = $wpdb->query("
1807 + DELETE FROM $wpdb->postmeta
1808 + WHERE post_id='$postId' AND meta_key='$key'
1809 + ");
1810 +
1811 + // Allow for either a single value or an array
1812 + if (!is_array($values)) $values = array($values);
1813 + foreach ( $values as $value ) :
1814 + $value = $wpdb->escape($value);
1815 + $result = $wpdb->query("
1816 + INSERT INTO $wpdb->postmeta
1817 + SET
1818 + post_id='$postId',
1819 + meta_key='$key',
1820 + meta_value='$value'
1821 + ");
1822 + endforeach;
1823 + endforeach;
1824 + endif;
1825 + } /* SyndicatedPost::add_rss_meta () */
1826 +
1827 + // SyndicatedPost::author_id (): get the ID for an author name from
1828 + // the feed. Create the author if necessary.
1829 + function author_id ($unfamiliar_author = 'create') {
1830 + global $wpdb;
1831 +
1832 + $a = $this->author();
1833 + $author = $a['name'];
1834 + $email = $a['email'];
1835 + $url = $a['uri'];
1836 +
1837 + $match_author_by_email = !('yes' == get_option("feedwordpress_do_not_match_author_by_email"));
1838 + if ($match_author_by_email and !FeedWordPress::is_null_email($email)) :
1839 + $test_email = $email;
1840 + else :
1841 + $test_email = NULL;
1842 + endif;
1843 +
1844 + // Never can be too careful...
1845 + $login = sanitize_user($author, /*strict=*/ true);
1846 + $login = apply_filters('pre_user_login', $login);
1847 +
1848 + $nice_author = sanitize_title($author);
1849 + $nice_author = apply_filters('pre_user_nicename', $nice_author);
1850 +
1851 + $reg_author = $wpdb->escape(preg_quote($author));
1852 + $author = $wpdb->escape($author);
1853 + $email = $wpdb->escape($email);
1854 + $test_email = $wpdb->escape($test_email);
1855 + $url = $wpdb->escape($url);
1856 +
1857 + // Check for an existing author rule....
1858 + if (isset($this->link->settings['map authors']['name'][strtolower(trim($author))])) :
1859 + $author_rule = $this->link->settings['map authors']['name'][strtolower(trim($author))];
1860 + else :
1861 + $author_rule = NULL;
1862 + endif;
1863 +
1864 + // User name is mapped to a particular author. If that author ID exists, use it.
1865 + if (is_numeric($author_rule) and get_userdata((int) $author_rule)) :
1866 + $id = (int) $author_rule;
1867 +
1868 + // User name is filtered out
1869 + elseif ('filter' == $author_rule) :
1870 + $id = NULL;
1871 +
1872 + else :
1873 + // Check the database for an existing author record that might fit
1874 +
1875 + #-- WordPress 2.0+
1876 + if (fwp_test_wp_version(FWP_SCHEMA_HAS_USERMETA)) :
1877 +
1878 + // First try the user core data table.
1879 + $id = $wpdb->get_var(
1880 + "SELECT ID FROM $wpdb->users
1881 + WHERE
1882 + TRIM(LCASE(user_login)) = TRIM(LCASE('$login'))
1883 + OR (
1884 + LENGTH(TRIM(LCASE(user_email))) > 0
1885 + AND TRIM(LCASE(user_email)) = TRIM(LCASE('$test_email'))
1886 + )
1887 + OR TRIM(LCASE(user_nicename)) = TRIM(LCASE('$nice_author'))
1888 + ");
1889 +
1890 + // If that fails, look for aliases in the user meta data table
1891 + if (is_null($id)) :
1892 + $id = $wpdb->get_var(
1893 + "SELECT user_id FROM $wpdb->usermeta
1894 + WHERE
1895 + (meta_key = 'description' AND TRIM(LCASE(meta_value)) = TRIM(LCASE('$author')))
1896 + OR (
1897 + meta_key = 'description'
1898 + AND TRIM(LCASE(meta_value))
1899 + RLIKE CONCAT(
1900 + '(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*',
1901 + TRIM(LCASE('$reg_author')),
1902 + '( |\\t|\\r)*(\\n|\$)'
1903 + )
1904 + )
1905 + ");
1906 + endif;
1907 +
1908 + #-- WordPress 1.5.x
1909 + else :
1910 + $id = $wpdb->get_var(
1911 + "SELECT ID from $wpdb->users
1912 + WHERE
1913 + TRIM(LCASE(user_login)) = TRIM(LCASE('$login')) OR
1914 + (
1915 + LENGTH(TRIM(LCASE(user_email))) > 0
1916 + AND TRIM(LCASE(user_email)) = TRIM(LCASE('$test_email'))
1917 + ) OR
1918 + TRIM(LCASE(user_firstname)) = TRIM(LCASE('$author')) OR
1919 + TRIM(LCASE(user_nickname)) = TRIM(LCASE('$author')) OR
1920 + TRIM(LCASE(user_nicename)) = TRIM(LCASE('$nice_author')) OR
1921 + TRIM(LCASE(user_description)) = TRIM(LCASE('$author')) OR
1922 + (
1923 + LOWER(user_description)
1924 + RLIKE CONCAT(
1925 + '(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*',
1926 + LCASE('$reg_author'),
1927 + '( |\\t|\\r)*(\\n|\$)'
1928 + )
1929 + )
1930 + ");
1931 +
1932 + endif;
1933 +
1934 + // ... if you don't find one, then do what you need to do
1935 + if (is_null($id)) :
1936 + if ($unfamiliar_author === 'create') :
1937 + $userdata = array();
1938 +
1939 + #-- user table data
1940 + $userdata['ID'] = NULL; // new user
1941 + $userdata['user_login'] = $login;
1942 + $userdata['user_nicename'] = $nice_author;
1943 + $userdata['user_pass'] = substr(md5(uniqid(microtime())), 0, 6); // just something random to lock it up
1944 + $userdata['user_email'] = $email;
1945 + $userdata['user_url'] = $url;
1946 + $userdata['display_name'] = $author;
1947 +
1948 + $id = wp_insert_user($userdata);
1949 + elseif (is_numeric($unfamiliar_author) and get_userdata((int) $unfamiliar_author)) :
1950 + $id = (int) $unfamiliar_author;
1951 + elseif ($unfamiliar_author === 'default') :
1952 + $id = 1;
1953 + endif;
1954 + endif;
1955 + endif;
1956 +
1957 + if ($id) :
1958 + $this->link->settings['map authors']['name'][strtolower(trim($author))] = $id;
1959 + endif;
1960 + return $id;
1961 + } // function SyndicatedPost::author_id ()
1962 +
1963 + // look up (and create) category ids from a list of categories
1964 + function category_ids ($cats, $unfamiliar_category = 'create', $tags_too = false) {
1965 + global $wpdb;
1966 +
1967 + // We need to normalize whitespace because (1) trailing
1968 + // whitespace can cause PHP and MySQL not to see eye to eye on
1969 + // VARCHAR comparisons for some versions of MySQL (cf.
1970 + // <http://dev.mysql.com/doc/mysql/en/char.html>), and (2)
1971 + // because I doubt most people want to make a semantic
1972 + // distinction between 'Computers' and 'Computers '
1973 + $cats = array_map('trim', $cats);
1974 +
1975 + $tags = array();
1976 +
1977 + $cat_ids = array ();
1978 + foreach ($cats as $cat_name) :
1979 + if (preg_match('/^{#([0-9]+)}$/', $cat_name, $backref)) :
1980 + $cat_id = (int) $backref[1];
1981 + if (function_exists('is_term') and is_term($cat_id, 'category')) :
1982 + $cat_ids[] = $cat_id;
1983 + elseif (get_category($cat_id)) :
1984 + $cat_ids[] = $cat_id;
1985 + endif;
1986 + elseif (strlen($cat_name) > 0) :
1987 + $esc = $wpdb->escape($cat_name);
1988 + $resc = $wpdb->escape(preg_quote($cat_name));
1989 +
1990 + // WordPress 2.3+
1991 + if (function_exists('is_term')) :
1992 + $cat_id = is_term($cat_name, 'category');
1993 + if ($cat_id) :
1994 + $cat_ids[] = $cat_id['term_id'];
1995 + // There must be a better way to do this...
1996 + elseif ($results = $wpdb->get_results(
1997 + "SELECT term_id
1998 + FROM $wpdb->term_taxonomy
1999 + WHERE
2000 + LOWER(description) RLIKE
2001 + CONCAT('(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*', LOWER('{$resc}'), '( |\\t|\\r)*(\\n|\$)')"
2002 + )) :
2003 + foreach ($results AS $term) :
2004 + $cat_ids[] = (int) $term->term_id;
2005 + endforeach;
2006 + elseif ('tag'==$unfamiliar_category) :
2007 + $tags[] = $cat_name;
2008 + elseif ('create'===$unfamiliar_category) :
2009 + $term = wp_insert_term($cat_name, 'category');
2010 + if (is_wp_error($term)) :
2011 + FeedWordPress::noncritical_bug('term insertion problem', array('cat_name' => $cat_name, 'term' => $term, 'this' => $this), __LINE__);
2012 + else :
2013 + $cat_ids[] = $term['term_id'];
2014 + endif;
2015 + endif;
2016 +
2017 + // WordPress 1.5.x - 2.2.x
2018 + else :
2019 + $results = $wpdb->get_results(
2020 + "SELECT cat_ID
2021 + FROM $wpdb->categories
2022 + WHERE
2023 + (LOWER(cat_name) = LOWER('$esc'))
2024 + OR (LOWER(category_description)
2025 + RLIKE CONCAT('(^|\\n)a\\.?k\\.?a\\.?( |\\t)*:?( |\\t)*', LOWER('{$resc}'), '( |\\t|\\r)*(\\n|\$)'))
2026 + ");
2027 + if ($results) :
2028 + foreach ($results as $term) :
2029 + $cat_ids[] = (int) $term->cat_ID;
2030 + endforeach;
2031 + elseif ('create'===$unfamiliar_category) :
2032 + if (function_exists('wp_insert_category')) :
2033 + $cat_id = wp_insert_category(array('cat_name' => $cat_name));
2034 + // And into the database we go.
2035 + else :
2036 + $nice_kitty = sanitize_title($cat_name);
2037 + $wpdb->query(sprintf("
2038 + INSERT INTO $wpdb->categories
2039 + SET
2040 + cat_name='%s',
2041 + category_nicename='%s'
2042 + ", $wpdb->escape($cat_name), $nice_kitty
2043 + ));
2044 + $cat_id = $wpdb->insert_id;
2045 + endif;
2046 + $cat_ids[] = $cat_id;
2047 + endif;
2048 + endif;
2049 + endif;
2050 + endforeach;
2051 +
2052 + if ((count($cat_ids) == 0) and ($unfamiliar_category === 'filter')) :
2053 + $cat_ids = NULL; // Drop the post
2054 + else :
2055 + $cat_ids = array_unique($cat_ids);
2056 + endif;
2057 +
2058 + if ($tags_too) : $ret = array($cat_ids, $tags);
2059 + else : $ret = $cat_ids;
2060 + endif;
2061 +
2062 + return $ret;
2063 + } // function SyndicatedPost::category_ids ()
2064 +
2065 + function use_api ($tag) {
2066 + global $wp_db_version;
2067 + switch ($tag) :
2068 + case 'wp_insert_post':
2069 + // Before 2.2, wp_insert_post does too much of the wrong stuff to use it
2070 + // In 1.5 it was such a resource hog it would make PHP segfault on big updates
2071 + $ret = (isset($wp_db_version) and $wp_db_version > FWP_SCHEMA_21);
2072 + break;
2073 + case 'post_status_pending':
2074 + $ret = (isset($wp_db_version) and $wp_db_version > FWP_SCHEMA_23);
2075 + break;
2076 + endswitch;
2077 + return $ret;
2078 + } // function SyndicatedPost::use_api ()
2079 +
2080 + #### EXTRACT DATA FROM FEED ITEM ####
2081 +
2082 + function created () {
2083 + $epoch = null;
2084 + if (isset($this->item['dc']['created'])) :
2085 + $epoch = @parse_w3cdtf($this->item['dc']['created']);
2086 + elseif (isset($this->item['dcterms']['created'])) :
2087 + $epoch = @parse_w3cdtf($this->item['dcterms']['created']);
2088 + elseif (isset($this->item['created'])): // Atom 0.3
2089 + $epoch = @parse_w3cdtf($this->item['created']);
2090 + endif;
2091 + return $epoch;
2092 + }
2093 + function published ($fallback = true) {
2094 + $epoch = null;
2095 +
2096 + # RSS is a fucking mess. Figure out whether we have a date in
2097 + # <dc:date>, <issued>, <pubDate>, etc., and get it into Unix
2098 + # epoch format for reformatting. If we can't find anything,
2099 + # we'll use the last-updated time.
2100 + if (isset($this->item['dc']['date'])): // Dublin Core
2101 + $epoch = @parse_w3cdtf($this->item['dc']['date']);
2102 + elseif (isset($this->item['dcterms']['issued'])) : // Dublin Core extensions
2103 + $epoch = @parse_w3cdtf($this->item['dcterms']['issued']);
2104 + elseif (isset($this->item['published'])) : // Atom 1.0
2105 + $epoch = @parse_w3cdtf($this->item['published']);
2106 + elseif (isset($this->item['issued'])): // Atom 0.3
2107 + $epoch = @parse_w3cdtf($this->item['issued']);
2108 + elseif (isset($this->item['pubdate'])): // RSS 2.0
2109 + $epoch = strtotime($this->item['pubdate']);
2110 + elseif ($fallback) : // Fall back to <updated> / <modified> if present
2111 + $epoch = $this->updated(/*fallback=*/ false);
2112 + endif;
2113 +
2114 + # If everything failed, then default to the current time.
2115 + if (is_null($epoch)) :
2116 + if (-1 == $default) :
2117 + $epoch = time();
2118 + else :
2119 + $epoch = $default;
2120 + endif;
2121 + endif;
2122 +
2123 + return $epoch;
2124 + }
2125 + function updated ($fallback = true, $default = -1) {
2126 + $epoch = null;
2127 +
2128 + # As far as I know, only dcterms and Atom have reliable ways to
2129 + # specify when something was *modified* last. If neither is
2130 + # available, then we'll try to get the time of publication.
2131 + if (isset($this->item['dc']['modified'])) : // Not really correct
2132 + $epoch = @parse_w3cdtf($this->item['dc']['modified']);
2133 + elseif (isset($this->item['dcterms']['modified'])) : // Dublin Core extensions
2134 + $epoch = @parse_w3cdtf($this->item['dcterms']['modified']);
2135 + elseif (isset($this->item['modified'])): // Atom 0.3
2136 + $epoch = @parse_w3cdtf($this->item['modified']);
2137 + elseif (isset($this->item['updated'])): // Atom 1.0
2138 + $epoch = @parse_w3cdtf($this->item['updated']);
2139 + elseif ($fallback) : // Fall back to issued / dc:date
2140 + $epoch = $this->published(/*fallback=*/ false, /*default=*/ $default);
2141 + endif;
2142 +
2143 + # If everything failed, then default to the current time.
2144 + if (is_null($epoch)) :
2145 + if (-1 == $default) :
2146 + $epoch = time();
2147 + else :
2148 + $epoch = $default;
2149 + endif;
2150 + endif;
2151 +
2152 + return $epoch;
2153 + }
2154 +
2155 + function update_hash () {
2156 + return md5(serialize($this->item));
2157 + }
2158 +
2159 + function guid () {
2160 + $guid = null;
2161 + if (isset($this->item['id'])): // Atom 0.3 / 1.0
2162 + $guid = $this->item['id'];
2163 + elseif (isset($this->item['atom']['id'])) : // Namespaced Atom
2164 + $guid = $this->item['atom']['id'];
2165 + elseif (isset($this->item['guid'])) : // RSS 2.0
2166 + $guid = $this->item['guid'];
2167 + elseif (isset($this->item['dc']['identifier'])) :// yeah, right
2168 + $guid = $this->item['dc']['identifier'];
2169 + else :
2170 + // The feed does not seem to have provided us with a
2171 + // unique identifier, so we'll have to cobble together
2172 + // a tag: URI that might work for us. The base of the
2173 + // URI will be the host name of the feed source ...
2174 + $bits = parse_url($this->feedmeta['link/uri']);
2175 + $guid = 'tag:'.$bits['host'];
2176 +
2177 + // If we have a date of creation, then we can use that
2178 + // to uniquely identify the item. (On the other hand, if
2179 + // the feed producer was consicentious enough to
2180 + // generate dates of creation, she probably also was
2181 + // conscientious enough to generate unique identifiers.)
2182 + if (!is_null($this->created())) :
2183 + $guid .= '://post.'.date('YmdHis', $this->created());
2184 +
2185 + // Otherwise, use both the URI of the item, *and* the
2186 + // item's title. We have to use both because titles are
2187 + // often not unique, and sometimes links aren't unique
2188 + // either (e.g. Bitch (S)HITLIST, Mozilla Dot Org news,
2189 + // some podcasts). But it's rare to have *both* the same
2190 + // title *and* the same link for two different items. So
2191 + // this is about the best we can do.
2192 + else :
2193 + $guid .= '://'.md5($this->item['link'].'/'.$this->item['title']);
2194 + endif;
2195 + endif;
2196 + return $guid;
2197 + }
2198 +
2199 + function author () {
2200 + $author = array ();
2201 +
2202 + if (isset($this->item['author_name'])):
2203 + $author['name'] = $this->item['author_name'];
2204 + elseif (isset($this->item['dc']['creator'])):
2205 + $author['name'] = $this->item['dc']['creator'];
2206 + elseif (isset($this->item['dc']['contributor'])):
2207 + $author['name'] = $this->item['dc']['contributor'];
2208 + elseif (isset($this->feed->channel['dc']['creator'])) :
2209 + $author['name'] = $this->feed->channel['dc']['creator'];
2210 + elseif (isset($this->feed->channel['dc']['contributor'])) :
2211 + $author['name'] = $this->feed->channel['dc']['contributor'];
2212 + elseif (isset($this->feed->channel['author_name'])) :
2213 + $author['name'] = $this->feed->channel['author_name'];
2214 + elseif ($this->feed->is_rss() and isset($this->item['author'])) :
2215 + // The author element in RSS is allegedly an
2216 + // e-mail address, but lots of people don't use
2217 + // it that way. So let's make of it what we can.
2218 + $author = parse_email_with_realname($this->item['author']);
2219 +
2220 + if (!isset($author['name'])) :
2221 + if (isset($author['email'])) :
2222 + $author['name'] = $author['email'];
2223 + else :
2224 + $author['name'] = $this->feed->channel['title'];
2225 + endif;
2226 + endif;
2227 + else :
2228 + $author['name'] = $this->feed->channel['title'];
2229 + endif;
2230 +
2231 + if (isset($this->item['author_email'])):
2232 + $author['email'] = $this->item['author_email'];
2233 + elseif (isset($this->feed->channel['author_email'])) :
2234 + $author['email'] = $this->feed->channel['author_email'];
2235 + endif;
2236 +
2237 + if (isset($this->item['author_url'])):
2238 + $author['uri'] = $this->item['author_url'];
2239 + elseif (isset($this->feed->channel['author_url'])) :
2240 + $author['uri'] = $this->item['author_url'];
2241 + else:
2242 + $author['uri'] = $this->feed->channel['link'];
2243 + endif;
2244 +
2245 + return $author;
2246 + } // SyndicatedPost::author()
2247 +
2248 + var $uri_attrs = array (
2249 + array('a', 'href'),
2250 + array('applet', 'codebase'),
2251 + array('area', 'href'),
2252 + array('blockquote', 'cite'),
2253 + array('body', 'background'),
2254 + array('del', 'cite'),
2255 + array('form', 'action'),
2256 + array('frame', 'longdesc'),
2257 + array('frame', 'src'),
2258 + array('iframe', 'longdesc'),
2259 + array('iframe', 'src'),
2260 + array('head', 'profile'),
2261 + array('img', 'longdesc'),
2262 + array('img', 'src'),
2263 + array('img', 'usemap'),
2264 + array('input', 'src'),
2265 + array('input', 'usemap'),
2266 + array('ins', 'cite'),
2267 + array('link', 'href'),
2268 + array('object', 'classid'),
2269 + array('object', 'codebase'),
2270 + array('object', 'data'),
2271 + array('object', 'usemap'),
2272 + array('q', 'cite'),
2273 + array('script', 'src')
2274 + ); /* var SyndicatedPost::$uri_attrs */
2275 +
2276 + var $_base = null;
2277 +
2278 + function resolve_single_relative_uri ($refs) {
2279 + $tag = FeedWordPressHTML::attributeMatch($refs);
2280 + $url = Relative_URI::resolve($tag['value'], $this->_base);
2281 + return $tag['prefix'] . $url . $tag['suffix'];
2282 + } /* function SyndicatedPost::resolve_single_relative_uri() */
2283 +
2284 + function resolve_relative_uris ($content, $obj) {
2285 + # The MagpieRSS upgrade has some `xml:base` support baked in.
2286 + # However, sometimes people do silly things, like putting
2287 + # relative URIs out on a production RSS 2.0 feed or other feeds
2288 + # with no good support for `xml:base`. So we'll do our best to
2289 + # try to catch any remaining relative URIs and resolve them as
2290 + # best we can.
2291 + $obj->_base = $obj->item['link']; // Reset the base for resolving relative URIs
2292 +
2293 + foreach ($obj->uri_attrs as $pair) :
2294 + list($tag, $attr) = $pair;
2295 + $pattern = FeedWordPressHTML::attributeRegex($tag, $attr);
2296 + $content = preg_replace_callback (
2297 + $pattern,
2298 + array(&$obj, 'resolve_single_relative_uri'),
2299 + $content
2300 + );
2301 + endforeach;
2302 +
2303 + return $content;
2304 + } /* function SyndicatedPost::resolve_relative_uris () */
2305 +
2306 + var $strip_attrs = array (
2307 + array('[a-z]+', 'target'),
2308 +// array('[a-z]+', 'style'),
2309 +// array('[a-z]+', 'on[a-z]+'),
2310 + );
2311 +
2312 + function strip_attribute_from_tag ($refs) {
2313 + $tag = FeedWordPressHTML::attributeMatch($refs);
2314 + return $tag['before_attribute'].$tag['after_attribute'];
2315 + }
2316 +
2317 + function sanitize_content ($content, $obj) {
2318 + # This kind of sucks. I intend to replace it with
2319 + # lib_filter sometime soon.
2320 + foreach ($obj->strip_attrs as $pair):
2321 + list($tag,$attr) = $pair;
2322 + $pattern = FeedWordPressHTML::attributeRegex($tag, $attr);
2323 +
2324 + $content = preg_replace_callback (
2325 + $pattern,
2326 + array(&$obj, 'strip_attribute_from_tag'),
2327 + $content
2328 + );
2329 + endforeach;
2330 + return $content;
2331 + }
2332 +} // class SyndicatedPost
2333 +
1153 2334 require_once(dirname(__FILE__) . '/syndicatedlink.class.php');
1154 2335
1155 2336 ################################################################################
1156 2337 ## XML-RPC HOOKS: accept XML-RPC update pings from Contributors ################
@@ -1174,12 +2355,184 @@
1174 2355 return array('flerror' => false, 'message' => "Thanks for the ping.".implode(' and', $mesg));
1175 2356 endif;
1176 2357 }
1177 2358
2359 +# Relative URI static class: PHP class for resolving relative URLs
2360 +#
2361 +# This class is derived (under the terms of the GPL) from URL Class 0.3 by
2362 +# Keyvan Minoukadeh <keyvan@k1m.com>, which is great but more than we need
2363 +# for FeedWordPress's purposes. The class has been stripped down to a single
2364 +# public method: Relative_URI::resolve($url, $base), which resolves the URI in
2365 +# $url relative to the URI in $base
2366 +#
1178 2367 # The upgraded MagpieRSS also uses this class. So if we have it loaded
1179 2368 # in, don't load it again.
1180 2369 if (!class_exists('Relative_URI')) {
1181 - require_once(dirname(__FILE__) . '/relative_uri.class.php');
2370 +
2371 + class Relative_URI
2372 + {
2373 + // Resolve relative URI in $url against the base URI in $base. If $base
2374 + // is not supplied, then we use the REQUEST_URI of this script.
2375 + //
2376 + // I'm hoping this method reflects RFC 2396 Section 5.2
2377 + function resolve ($url, $base = NULL)
2378 + {
2379 + if (is_null($base)):
2380 + $base = 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
2381 + endif;
2382 +
2383 + $base = Relative_URI::_encode(trim($base));
2384 + $uri_parts = Relative_URI::_parse_url($base);
2385 +
2386 + $url = Relative_URI::_encode(trim($url));
2387 + $parts = Relative_URI::_parse_url($url);
2388 +
2389 + $uri_parts['fragment'] = (isset($parts['fragment']) ? $parts['fragment'] : null);
2390 + $uri_parts['query'] = (isset($parts['query']) ? $parts['query'] : null);
2391 +
2392 + // if path is empty, and scheme, host, and query are undefined,
2393 + // the URL is referring the base URL
2394 +
2395 + if (($parts['path'] == '') && !isset($parts['scheme']) && !isset($parts['host']) && !isset($parts['query'])) {
2396 + // If the URI is empty or only a fragment, return the base URI
2397 + return $base . (isset($parts['fragment']) ? '#'.$parts['fragment'] : '');
2398 + } elseif (isset($parts['scheme'])) {
2399 + // If the scheme is set, then the URI is absolute.
2400 + return $url;
2401 + } elseif (isset($parts['host'])) {
2402 + $uri_parts['host'] = $parts['host'];
2403 + $uri_parts['path'] = $parts['path'];
2404 + } else {
2405 + // We have a relative path but not a host.
2406 +
2407 + // start ugly fix:
2408 + // prepend slash to path if base host is set, base path is not set, and url path is not absolute
2409 + if ($uri_parts['host'] && ($uri_parts['path'] == '')
2410 + && (strlen($parts['path']) > 0)
2411 + && (substr($parts['path'], 0, 1) != '/')) {
2412 + $parts['path'] = '/'.$parts['path'];
2413 + } // end ugly fix
2414 +
2415 + if (substr($parts['path'], 0, 1) == '/') {
2416 + $uri_parts['path'] = $parts['path'];
2417 + } else {
2418 + // copy base path excluding any characters after the last (right-most) slash character
2419 + $buffer = substr($uri_parts['path'], 0, (int)strrpos($uri_parts['path'], '/')+1);
2420 + // append relative path
2421 + $buffer .= $parts['path'];
2422 + // remove "./" where "." is a complete path segment.
2423 + $buffer = str_replace('/./', '/', $buffer);
2424 + if (substr($buffer, 0, 2) == './') {
2425 + $buffer = substr($buffer, 2);
2426 + }
2427 + // if buffer ends with "." as a complete path segment, remove it
2428 + if (substr($buffer, -2) == '/.') {
2429 + $buffer = substr($buffer, 0, -1);
2430 + }
2431 + // remove "<segment>/../" where <segment> is a complete path segment not equal to ".."
2432 + $search_finished = false;
2433 + $segment = explode('/', $buffer);
2434 + while (!$search_finished) {
2435 + for ($x=0; $x+1 < count($segment);) {
2436 + if (($segment[$x] != '') && ($segment[$x] != '..') && ($segment[$x+1] == '..')) {
2437 + if ($x+2 == count($segment)) $segment[] = '';
2438 + unset($segment[$x], $segment[$x+1]);
2439 + $segment = array_values($segment);
2440 + continue 2;
2441 + } else {
2442 + $x++;
2443 + }
2444 + }
2445 + $search_finished = true;
2446 + }
2447 + $buffer = (count($segment) == 1) ? '/' : implode('/', $segment);
2448 + $uri_parts['path'] = $buffer;
2449 +
2450 + }
2451 + }
2452 +
2453 + // If we've gotten to this point, we can try to put the pieces
2454 + // back together.
2455 + $ret = '';
2456 + if (isset($uri_parts['scheme'])) $ret .= $uri_parts['scheme'].':';
2457 + if (isset($uri_parts['user'])) {
2458 + $ret .= $uri_parts['user'];
2459 + if (isset($uri_parts['pass'])) $ret .= ':'.$uri_parts['parts'];
2460 + $ret .= '@';
2461 + }
2462 + if (isset($uri_parts['host'])) {
2463 + $ret .= '//'.$uri_parts['host'];
2464 + if (isset($uri_parts['port'])) $ret .= ':'.$uri_parts['port'];
2465 + }
2466 + $ret .= $uri_parts['path'];
2467 + if (isset($uri_parts['query'])) $ret .= '?'.$uri_parts['query'];
2468 + if (isset($uri_parts['fragment'])) $ret .= '#'.$uri_parts['fragment'];
2469 +
2470 + return $ret;
2471 + }
2472 +
2473 + /**
2474 + * Parse URL
2475 + *
2476 + * Regular expression grabbed from RFC 2396 Appendix B.
2477 + * This is a replacement for PHPs builtin parse_url().
2478 + * @param string $url
2479 + * @access private
2480 + * @return array
2481 + */
2482 + function _parse_url($url)
2483 + {
2484 + // I'm using this pattern instead of parse_url() as there's a few strings where parse_url()
2485 + // generates a warning.
2486 + if (preg_match('!^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?!', $url, $match)) {
2487 + $parts = array();
2488 + if ($match[1] != '') $parts['scheme'] = $match[2];
2489 + if ($match[3] != '') $parts['auth'] = $match[4];
2490 + // parse auth
2491 + if (isset($parts['auth'])) {
2492 + // store user info
2493 + if (($at_pos = strpos($parts['auth'], '@')) !== false) {
2494 + $userinfo = explode(':', substr($parts['auth'], 0, $at_pos), 2);
2495 + $parts['user'] = $userinfo[0];
2496 + if (isset($userinfo[1])) $parts['pass'] = $userinfo[1];
2497 + $parts['auth'] = substr($parts['auth'], $at_pos+1);
2498 + }
2499 + // get port number
2500 + if ($port_pos = strrpos($parts['auth'], ':')) {
2501 + $parts['host'] = substr($parts['auth'], 0, $port_pos);
2502 + $parts['port'] = (int)substr($parts['auth'], $port_pos+1);
2503 + if ($parts['port'] < 1) $parts['port'] = null;
2504 + } else {
2505 + $parts['host'] = $parts['auth'];
2506 + }
2507 + }
2508 + unset($parts['auth']);
2509 + $parts['path'] = $match[5];
2510 + if (isset($match[6]) && ($match[6] != '')) $parts['query'] = $match[7];
2511 + if (isset($match[8]) && ($match[8] != '')) $parts['fragment'] = $match[9];
2512 + return $parts;
2513 + }
2514 + // shouldn't reach here
2515 + return array('path'=>'');
2516 + }
2517 +
2518 + function _encode($string)
2519 + {
2520 + static $replace = array();
2521 + if (!count($replace)) {
2522 + $find = array(32, 34, 60, 62, 123, 124, 125, 91, 92, 93, 94, 96, 127);
2523 + $find = array_merge(range(0, 31), $find);
2524 + $find = array_map('chr', $find);
2525 + foreach ($find as $char) {
2526 + $replace[$char] = '%'.bin2hex($char);
2527 + }
2528 + }
2529 + // escape control characters and a few other characters
2530 + $encoded = strtr($string, $replace);
2531 + // remove any character outside the hex range: 21 - 7E (see www.asciitable.com)
2532 + return preg_replace('/[^\x21-\x7e]/', '', $encoded);
2533 + }
2534 + } // class Relative_URI
1182 2535 }
1183 2536
1184 2537 // take your best guess at the realname and e-mail, given a string
1185 2538 define('FWP_REGEX_EMAIL_ADDY', '([^@"(<\s]+@[^"@(<\s]+\.[^"@(<\s]+)');