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