| [ Index ] |
PHP Cross Reference of WordPress Trunk (Updated Daily) |
[Summary view] [Print] [Text view]
1 <?php 2 if ( ! class_exists( 'SimplePie', false ) ) : 3 4 // Load classes we will need. 5 require ABSPATH . WPINC . '/SimplePie/Misc.php'; 6 require ABSPATH . WPINC . '/SimplePie/Cache.php'; 7 require ABSPATH . WPINC . '/SimplePie/File.php'; 8 require ABSPATH . WPINC . '/SimplePie/Sanitize.php'; 9 require ABSPATH . WPINC . '/SimplePie/Registry.php'; 10 require ABSPATH . WPINC . '/SimplePie/IRI.php'; 11 require ABSPATH . WPINC . '/SimplePie/Locator.php'; 12 require ABSPATH . WPINC . '/SimplePie/Content/Type/Sniffer.php'; 13 require ABSPATH . WPINC . '/SimplePie/XML/Declaration/Parser.php'; 14 require ABSPATH . WPINC . '/SimplePie/Parser.php'; 15 require ABSPATH . WPINC . '/SimplePie/Item.php'; 16 require ABSPATH . WPINC . '/SimplePie/Parse/Date.php'; 17 require ABSPATH . WPINC . '/SimplePie/Author.php'; 18 19 /** 20 * WordPress autoloader for SimplePie. 21 * 22 * @since 3.5.0 23 * 24 * @param string $class Class name. 25 */ 26 function wp_simplepie_autoload( $class ) { 27 if ( ! str_starts_with( $class, 'SimplePie_' ) ) 28 return; 29 30 $file = ABSPATH . WPINC . '/' . str_replace( '_', '/', $class ) . '.php'; 31 include $file; 32 } 33 34 /** 35 * We autoload classes we may not need. 36 */ 37 spl_autoload_register( 'wp_simplepie_autoload' ); 38 39 /** 40 * SimplePie 41 * 42 * A PHP-Based RSS and Atom Feed Framework. 43 * Takes the hard work out of managing a complete RSS/Atom solution. 44 * 45 * Copyright (c) 2004-2017, Ryan Parman, Sam Sneddon, Ryan McCue, and contributors 46 * All rights reserved. 47 * 48 * Redistribution and use in source and binary forms, with or without modification, are 49 * permitted provided that the following conditions are met: 50 * 51 * * Redistributions of source code must retain the above copyright notice, this list of 52 * conditions and the following disclaimer. 53 * 54 * * Redistributions in binary form must reproduce the above copyright notice, this list 55 * of conditions and the following disclaimer in the documentation and/or other materials 56 * provided with the distribution. 57 * 58 * * Neither the name of the SimplePie Team nor the names of its contributors may be used 59 * to endorse or promote products derived from this software without specific prior 60 * written permission. 61 * 62 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 63 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 64 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS 65 * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 66 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 67 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 68 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 69 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 70 * POSSIBILITY OF SUCH DAMAGE. 71 * 72 * @package SimplePie 73 * @version 1.5.8 74 * @copyright 2004-2017 Ryan Parman, Sam Sneddon, Ryan McCue 75 * @author Ryan Parman 76 * @author Sam Sneddon 77 * @author Ryan McCue 78 * @link http://simplepie.org/ SimplePie 79 * @license http://www.opensource.org/licenses/bsd-license.php BSD License 80 */ 81 82 /** 83 * SimplePie Name 84 */ 85 define('SIMPLEPIE_NAME', 'SimplePie'); 86 87 /** 88 * SimplePie Version 89 */ 90 define('SIMPLEPIE_VERSION', '1.5.8'); 91 92 /** 93 * SimplePie Build 94 * @todo Hardcode for release (there's no need to have to call SimplePie_Misc::get_build() only every load of simplepie.inc) 95 */ 96 define('SIMPLEPIE_BUILD', gmdate('YmdHis', SimplePie_Misc::get_build())); 97 98 /** 99 * SimplePie Website URL 100 */ 101 define('SIMPLEPIE_URL', 'http://simplepie.org'); 102 103 /** 104 * SimplePie Useragent 105 * @see SimplePie::set_useragent() 106 */ 107 define('SIMPLEPIE_USERAGENT', SIMPLEPIE_NAME . '/' . SIMPLEPIE_VERSION . ' (Feed Parser; ' . SIMPLEPIE_URL . '; Allow like Gecko) Build/' . SIMPLEPIE_BUILD); 108 109 /** 110 * SimplePie Linkback 111 */ 112 define('SIMPLEPIE_LINKBACK', '<a href="' . SIMPLEPIE_URL . '" title="' . SIMPLEPIE_NAME . ' ' . SIMPLEPIE_VERSION . '">' . SIMPLEPIE_NAME . '</a>'); 113 114 /** 115 * No Autodiscovery 116 * @see SimplePie::set_autodiscovery_level() 117 */ 118 define('SIMPLEPIE_LOCATOR_NONE', 0); 119 120 /** 121 * Feed Link Element Autodiscovery 122 * @see SimplePie::set_autodiscovery_level() 123 */ 124 define('SIMPLEPIE_LOCATOR_AUTODISCOVERY', 1); 125 126 /** 127 * Local Feed Extension Autodiscovery 128 * @see SimplePie::set_autodiscovery_level() 129 */ 130 define('SIMPLEPIE_LOCATOR_LOCAL_EXTENSION', 2); 131 132 /** 133 * Local Feed Body Autodiscovery 134 * @see SimplePie::set_autodiscovery_level() 135 */ 136 define('SIMPLEPIE_LOCATOR_LOCAL_BODY', 4); 137 138 /** 139 * Remote Feed Extension Autodiscovery 140 * @see SimplePie::set_autodiscovery_level() 141 */ 142 define('SIMPLEPIE_LOCATOR_REMOTE_EXTENSION', 8); 143 144 /** 145 * Remote Feed Body Autodiscovery 146 * @see SimplePie::set_autodiscovery_level() 147 */ 148 define('SIMPLEPIE_LOCATOR_REMOTE_BODY', 16); 149 150 /** 151 * All Feed Autodiscovery 152 * @see SimplePie::set_autodiscovery_level() 153 */ 154 define('SIMPLEPIE_LOCATOR_ALL', 31); 155 156 /** 157 * No known feed type 158 */ 159 define('SIMPLEPIE_TYPE_NONE', 0); 160 161 /** 162 * RSS 0.90 163 */ 164 define('SIMPLEPIE_TYPE_RSS_090', 1); 165 166 /** 167 * RSS 0.91 (Netscape) 168 */ 169 define('SIMPLEPIE_TYPE_RSS_091_NETSCAPE', 2); 170 171 /** 172 * RSS 0.91 (Userland) 173 */ 174 define('SIMPLEPIE_TYPE_RSS_091_USERLAND', 4); 175 176 /** 177 * RSS 0.91 (both Netscape and Userland) 178 */ 179 define('SIMPLEPIE_TYPE_RSS_091', 6); 180 181 /** 182 * RSS 0.92 183 */ 184 define('SIMPLEPIE_TYPE_RSS_092', 8); 185 186 /** 187 * RSS 0.93 188 */ 189 define('SIMPLEPIE_TYPE_RSS_093', 16); 190 191 /** 192 * RSS 0.94 193 */ 194 define('SIMPLEPIE_TYPE_RSS_094', 32); 195 196 /** 197 * RSS 1.0 198 */ 199 define('SIMPLEPIE_TYPE_RSS_10', 64); 200 201 /** 202 * RSS 2.0 203 */ 204 define('SIMPLEPIE_TYPE_RSS_20', 128); 205 206 /** 207 * RDF-based RSS 208 */ 209 define('SIMPLEPIE_TYPE_RSS_RDF', 65); 210 211 /** 212 * Non-RDF-based RSS (truly intended as syndication format) 213 */ 214 define('SIMPLEPIE_TYPE_RSS_SYNDICATION', 190); 215 216 /** 217 * All RSS 218 */ 219 define('SIMPLEPIE_TYPE_RSS_ALL', 255); 220 221 /** 222 * Atom 0.3 223 */ 224 define('SIMPLEPIE_TYPE_ATOM_03', 256); 225 226 /** 227 * Atom 1.0 228 */ 229 define('SIMPLEPIE_TYPE_ATOM_10', 512); 230 231 /** 232 * All Atom 233 */ 234 define('SIMPLEPIE_TYPE_ATOM_ALL', 768); 235 236 /** 237 * All feed types 238 */ 239 define('SIMPLEPIE_TYPE_ALL', 1023); 240 241 /** 242 * No construct 243 */ 244 define('SIMPLEPIE_CONSTRUCT_NONE', 0); 245 246 /** 247 * Text construct 248 */ 249 define('SIMPLEPIE_CONSTRUCT_TEXT', 1); 250 251 /** 252 * HTML construct 253 */ 254 define('SIMPLEPIE_CONSTRUCT_HTML', 2); 255 256 /** 257 * XHTML construct 258 */ 259 define('SIMPLEPIE_CONSTRUCT_XHTML', 4); 260 261 /** 262 * base64-encoded construct 263 */ 264 define('SIMPLEPIE_CONSTRUCT_BASE64', 8); 265 266 /** 267 * IRI construct 268 */ 269 define('SIMPLEPIE_CONSTRUCT_IRI', 16); 270 271 /** 272 * A construct that might be HTML 273 */ 274 define('SIMPLEPIE_CONSTRUCT_MAYBE_HTML', 32); 275 276 /** 277 * All constructs 278 */ 279 define('SIMPLEPIE_CONSTRUCT_ALL', 63); 280 281 /** 282 * Don't change case 283 */ 284 define('SIMPLEPIE_SAME_CASE', 1); 285 286 /** 287 * Change to lowercase 288 */ 289 define('SIMPLEPIE_LOWERCASE', 2); 290 291 /** 292 * Change to uppercase 293 */ 294 define('SIMPLEPIE_UPPERCASE', 4); 295 296 /** 297 * PCRE for HTML attributes 298 */ 299 define('SIMPLEPIE_PCRE_HTML_ATTRIBUTE', '((?:[\x09\x0A\x0B\x0C\x0D\x20]+[^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3D\x3E]*(?:[\x09\x0A\x0B\x0C\x0D\x20]*=[\x09\x0A\x0B\x0C\x0D\x20]*(?:"(?:[^"]*)"|\'(?:[^\']*)\'|(?:[^\x09\x0A\x0B\x0C\x0D\x20\x22\x27\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x3E]*)?))?)*)[\x09\x0A\x0B\x0C\x0D\x20]*'); 300 301 /** 302 * PCRE for XML attributes 303 */ 304 define('SIMPLEPIE_PCRE_XML_ATTRIBUTE', '((?:\s+(?:(?:[^\s:]+:)?[^\s:]+)\s*=\s*(?:"(?:[^"]*)"|\'(?:[^\']*)\'))*)\s*'); 305 306 /** 307 * XML Namespace 308 */ 309 define('SIMPLEPIE_NAMESPACE_XML', 'http://www.w3.org/XML/1998/namespace'); 310 311 /** 312 * Atom 1.0 Namespace 313 */ 314 define('SIMPLEPIE_NAMESPACE_ATOM_10', 'http://www.w3.org/2005/Atom'); 315 316 /** 317 * Atom 0.3 Namespace 318 */ 319 define('SIMPLEPIE_NAMESPACE_ATOM_03', 'http://purl.org/atom/ns#'); 320 321 /** 322 * RDF Namespace 323 */ 324 define('SIMPLEPIE_NAMESPACE_RDF', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'); 325 326 /** 327 * RSS 0.90 Namespace 328 */ 329 define('SIMPLEPIE_NAMESPACE_RSS_090', 'http://my.netscape.com/rdf/simple/0.9/'); 330 331 /** 332 * RSS 1.0 Namespace 333 */ 334 define('SIMPLEPIE_NAMESPACE_RSS_10', 'http://purl.org/rss/1.0/'); 335 336 /** 337 * RSS 1.0 Content Module Namespace 338 */ 339 define('SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT', 'http://purl.org/rss/1.0/modules/content/'); 340 341 /** 342 * RSS 2.0 Namespace 343 */ 344 define('SIMPLEPIE_NAMESPACE_RSS_20', ''); 345 346 /** 347 * DC 1.0 Namespace 348 */ 349 define('SIMPLEPIE_NAMESPACE_DC_10', 'http://purl.org/dc/elements/1.0/'); 350 351 /** 352 * DC 1.1 Namespace 353 */ 354 define('SIMPLEPIE_NAMESPACE_DC_11', 'http://purl.org/dc/elements/1.1/'); 355 356 /** 357 * W3C Basic Geo (WGS84 lat/long) Vocabulary Namespace 358 */ 359 define('SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO', 'http://www.w3.org/2003/01/geo/wgs84_pos#'); 360 361 /** 362 * GeoRSS Namespace 363 */ 364 define('SIMPLEPIE_NAMESPACE_GEORSS', 'http://www.georss.org/georss'); 365 366 /** 367 * Media RSS Namespace 368 */ 369 define('SIMPLEPIE_NAMESPACE_MEDIARSS', 'http://search.yahoo.com/mrss/'); 370 371 /** 372 * Wrong Media RSS Namespace. Caused by a long-standing typo in the spec. 373 */ 374 define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG', 'http://search.yahoo.com/mrss'); 375 376 /** 377 * Wrong Media RSS Namespace #2. New namespace introduced in Media RSS 1.5. 378 */ 379 define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG2', 'http://video.search.yahoo.com/mrss'); 380 381 /** 382 * Wrong Media RSS Namespace #3. A possible typo of the Media RSS 1.5 namespace. 383 */ 384 define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG3', 'http://video.search.yahoo.com/mrss/'); 385 386 /** 387 * Wrong Media RSS Namespace #4. New spec location after the RSS Advisory Board takes it over, but not a valid namespace. 388 */ 389 define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG4', 'http://www.rssboard.org/media-rss'); 390 391 /** 392 * Wrong Media RSS Namespace #5. A possible typo of the RSS Advisory Board URL. 393 */ 394 define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG5', 'http://www.rssboard.org/media-rss/'); 395 396 /** 397 * iTunes RSS Namespace 398 */ 399 define('SIMPLEPIE_NAMESPACE_ITUNES', 'http://www.itunes.com/dtds/podcast-1.0.dtd'); 400 401 /** 402 * XHTML Namespace 403 */ 404 define('SIMPLEPIE_NAMESPACE_XHTML', 'http://www.w3.org/1999/xhtml'); 405 406 /** 407 * IANA Link Relations Registry 408 */ 409 define('SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY', 'http://www.iana.org/assignments/relation/'); 410 411 /** 412 * No file source 413 */ 414 define('SIMPLEPIE_FILE_SOURCE_NONE', 0); 415 416 /** 417 * Remote file source 418 */ 419 define('SIMPLEPIE_FILE_SOURCE_REMOTE', 1); 420 421 /** 422 * Local file source 423 */ 424 define('SIMPLEPIE_FILE_SOURCE_LOCAL', 2); 425 426 /** 427 * fsockopen() file source 428 */ 429 define('SIMPLEPIE_FILE_SOURCE_FSOCKOPEN', 4); 430 431 /** 432 * cURL file source 433 */ 434 define('SIMPLEPIE_FILE_SOURCE_CURL', 8); 435 436 /** 437 * file_get_contents() file source 438 */ 439 define('SIMPLEPIE_FILE_SOURCE_FILE_GET_CONTENTS', 16); 440 441 442 443 /** 444 * SimplePie 445 * 446 * @package SimplePie 447 * @subpackage API 448 */ 449 class SimplePie 450 { 451 /** 452 * @var array Raw data 453 * @access private 454 */ 455 public $data = array(); 456 457 /** 458 * @var mixed Error string 459 * @access private 460 */ 461 public $error; 462 463 /** 464 * @var int HTTP status code 465 * @see SimplePie::status_code() 466 * @access private 467 */ 468 public $status_code; 469 470 /** 471 * @var object Instance of SimplePie_Sanitize (or other class) 472 * @see SimplePie::set_sanitize_class() 473 * @access private 474 */ 475 public $sanitize; 476 477 /** 478 * @var string SimplePie Useragent 479 * @see SimplePie::set_useragent() 480 * @access private 481 */ 482 public $useragent = SIMPLEPIE_USERAGENT; 483 484 /** 485 * @var string Feed URL 486 * @see SimplePie::set_feed_url() 487 * @access private 488 */ 489 public $feed_url; 490 491 /** 492 * @var string Original feed URL, or new feed URL iff HTTP 301 Moved Permanently 493 * @see SimplePie::subscribe_url() 494 * @access private 495 */ 496 public $permanent_url = null; 497 498 /** 499 * @var object Instance of SimplePie_File to use as a feed 500 * @see SimplePie::set_file() 501 * @access private 502 */ 503 public $file; 504 505 /** 506 * @var string Raw feed data 507 * @see SimplePie::set_raw_data() 508 * @access private 509 */ 510 public $raw_data; 511 512 /** 513 * @var int Timeout for fetching remote files 514 * @see SimplePie::set_timeout() 515 * @access private 516 */ 517 public $timeout = 10; 518 519 /** 520 * @var array Custom curl options 521 * @see SimplePie::set_curl_options() 522 * @access private 523 */ 524 public $curl_options = array(); 525 526 /** 527 * @var bool Forces fsockopen() to be used for remote files instead 528 * of cURL, even if a new enough version is installed 529 * @see SimplePie::force_fsockopen() 530 * @access private 531 */ 532 public $force_fsockopen = false; 533 534 /** 535 * @var bool Force the given data/URL to be treated as a feed no matter what 536 * it appears like 537 * @see SimplePie::force_feed() 538 * @access private 539 */ 540 public $force_feed = false; 541 542 /** 543 * @var bool Enable/Disable Caching 544 * @see SimplePie::enable_cache() 545 * @access private 546 */ 547 public $cache = true; 548 549 /** 550 * @var bool Force SimplePie to fallback to expired cache, if enabled, 551 * when feed is unavailable. 552 * @see SimplePie::force_cache_fallback() 553 * @access private 554 */ 555 public $force_cache_fallback = false; 556 557 /** 558 * @var int Cache duration (in seconds) 559 * @see SimplePie::set_cache_duration() 560 * @access private 561 */ 562 public $cache_duration = 3600; 563 564 /** 565 * @var int Auto-discovery cache duration (in seconds) 566 * @see SimplePie::set_autodiscovery_cache_duration() 567 * @access private 568 */ 569 public $autodiscovery_cache_duration = 604800; // 7 Days. 570 571 /** 572 * @var string Cache location (relative to executing script) 573 * @see SimplePie::set_cache_location() 574 * @access private 575 */ 576 public $cache_location = './cache'; 577 578 /** 579 * @var string Function that creates the cache filename 580 * @see SimplePie::set_cache_name_function() 581 * @access private 582 */ 583 public $cache_name_function = 'md5'; 584 585 /** 586 * @var bool Reorder feed by date descending 587 * @see SimplePie::enable_order_by_date() 588 * @access private 589 */ 590 public $order_by_date = true; 591 592 /** 593 * @var mixed Force input encoding to be set to the follow value 594 * (false, or anything type-cast to false, disables this feature) 595 * @see SimplePie::set_input_encoding() 596 * @access private 597 */ 598 public $input_encoding = false; 599 600 /** 601 * @var int Feed Autodiscovery Level 602 * @see SimplePie::set_autodiscovery_level() 603 * @access private 604 */ 605 public $autodiscovery = SIMPLEPIE_LOCATOR_ALL; 606 607 /** 608 * Class registry object 609 * 610 * @var SimplePie_Registry 611 */ 612 public $registry; 613 614 /** 615 * @var int Maximum number of feeds to check with autodiscovery 616 * @see SimplePie::set_max_checked_feeds() 617 * @access private 618 */ 619 public $max_checked_feeds = 10; 620 621 /** 622 * @var array All the feeds found during the autodiscovery process 623 * @see SimplePie::get_all_discovered_feeds() 624 * @access private 625 */ 626 public $all_discovered_feeds = array(); 627 628 /** 629 * @var string Web-accessible path to the handler_image.php file. 630 * @see SimplePie::set_image_handler() 631 * @access private 632 */ 633 public $image_handler = ''; 634 635 /** 636 * @var array Stores the URLs when multiple feeds are being initialized. 637 * @see SimplePie::set_feed_url() 638 * @access private 639 */ 640 public $multifeed_url = array(); 641 642 /** 643 * @var array Stores SimplePie objects when multiple feeds initialized. 644 * @access private 645 */ 646 public $multifeed_objects = array(); 647 648 /** 649 * @var array Stores the get_object_vars() array for use with multifeeds. 650 * @see SimplePie::set_feed_url() 651 * @access private 652 */ 653 public $config_settings = null; 654 655 /** 656 * @var integer Stores the number of items to return per-feed with multifeeds. 657 * @see SimplePie::set_item_limit() 658 * @access private 659 */ 660 public $item_limit = 0; 661 662 /** 663 * @var bool Stores if last-modified and/or etag headers were sent with the 664 * request when checking a feed. 665 */ 666 public $check_modified = false; 667 668 /** 669 * @var array Stores the default attributes to be stripped by strip_attributes(). 670 * @see SimplePie::strip_attributes() 671 * @access private 672 */ 673 public $strip_attributes = array('bgsound', 'class', 'expr', 'id', 'style', 'onclick', 'onerror', 'onfinish', 'onmouseover', 'onmouseout', 'onfocus', 'onblur', 'lowsrc', 'dynsrc'); 674 675 /** 676 * @var array Stores the default attributes to add to different tags by add_attributes(). 677 * @see SimplePie::add_attributes() 678 * @access private 679 */ 680 public $add_attributes = array('audio' => array('preload' => 'none'), 'iframe' => array('sandbox' => 'allow-scripts allow-same-origin'), 'video' => array('preload' => 'none')); 681 682 /** 683 * @var array Stores the default tags to be stripped by strip_htmltags(). 684 * @see SimplePie::strip_htmltags() 685 * @access private 686 */ 687 public $strip_htmltags = array('base', 'blink', 'body', 'doctype', 'embed', 'font', 'form', 'frame', 'frameset', 'html', 'iframe', 'input', 'marquee', 'meta', 'noscript', 'object', 'param', 'script', 'style'); 688 689 /** 690 * @var bool Should we throw exceptions, or use the old-style error property? 691 * @access private 692 */ 693 public $enable_exceptions = false; 694 695 /** 696 * The SimplePie class contains feed level data and options 697 * 698 * To use SimplePie, create the SimplePie object with no parameters. You can 699 * then set configuration options using the provided methods. After setting 700 * them, you must initialise the feed using $feed->init(). At that point the 701 * object's methods and properties will be available to you. 702 * 703 * Previously, it was possible to pass in the feed URL along with cache 704 * options directly into the constructor. This has been removed as of 1.3 as 705 * it caused a lot of confusion. 706 * 707 * @since 1.0 Preview Release 708 */ 709 public function __construct() 710 { 711 if (version_compare(PHP_VERSION, '5.6', '<')) 712 { 713 trigger_error('Please upgrade to PHP 5.6 or newer.'); 714 die(); 715 } 716 717 // Other objects, instances created here so we can set options on them 718 $this->sanitize = new SimplePie_Sanitize(); 719 $this->registry = new SimplePie_Registry(); 720 721 if (func_num_args() > 0) 722 { 723 $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 724 trigger_error('Passing parameters to the constructor is no longer supported. Please use set_feed_url(), set_cache_location(), and set_cache_duration() directly.', $level); 725 726 $args = func_get_args(); 727 switch (count($args)) { 728 case 3: 729 $this->set_cache_duration($args[2]); 730 case 2: 731 $this->set_cache_location($args[1]); 732 case 1: 733 $this->set_feed_url($args[0]); 734 $this->init(); 735 } 736 } 737 } 738 739 /** 740 * Used for converting object to a string 741 */ 742 public function __toString() 743 { 744 return md5(serialize($this->data)); 745 } 746 747 /** 748 * Remove items that link back to this before destroying this object 749 */ 750 public function __destruct() 751 { 752 if (!gc_enabled()) 753 { 754 if (!empty($this->data['items'])) 755 { 756 foreach ($this->data['items'] as $item) 757 { 758 $item->__destruct(); 759 } 760 unset($item, $this->data['items']); 761 } 762 if (!empty($this->data['ordered_items'])) 763 { 764 foreach ($this->data['ordered_items'] as $item) 765 { 766 $item->__destruct(); 767 } 768 unset($item, $this->data['ordered_items']); 769 } 770 } 771 } 772 773 /** 774 * Force the given data/URL to be treated as a feed 775 * 776 * This tells SimplePie to ignore the content-type provided by the server. 777 * Be careful when using this option, as it will also disable autodiscovery. 778 * 779 * @since 1.1 780 * @param bool $enable Force the given data/URL to be treated as a feed 781 */ 782 public function force_feed($enable = false) 783 { 784 $this->force_feed = (bool) $enable; 785 } 786 787 /** 788 * Set the URL of the feed you want to parse 789 * 790 * This allows you to enter the URL of the feed you want to parse, or the 791 * website you want to try to use auto-discovery on. This takes priority 792 * over any set raw data. 793 * 794 * You can set multiple feeds to mash together by passing an array instead 795 * of a string for the $url. Remember that with each additional feed comes 796 * additional processing and resources. 797 * 798 * @since 1.0 Preview Release 799 * @see set_raw_data() 800 * @param string|array $url This is the URL (or array of URLs) that you want to parse. 801 */ 802 public function set_feed_url($url) 803 { 804 $this->multifeed_url = array(); 805 if (is_array($url)) 806 { 807 foreach ($url as $value) 808 { 809 $this->multifeed_url[] = $this->registry->call('Misc', 'fix_protocol', array($value, 1)); 810 } 811 } 812 else 813 { 814 $this->feed_url = $this->registry->call('Misc', 'fix_protocol', array($url, 1)); 815 $this->permanent_url = $this->feed_url; 816 } 817 } 818 819 /** 820 * Set an instance of {@see SimplePie_File} to use as a feed 821 * 822 * @param SimplePie_File &$file 823 * @return bool True on success, false on failure 824 */ 825 public function set_file(&$file) 826 { 827 if ($file instanceof SimplePie_File) 828 { 829 $this->feed_url = $file->url; 830 $this->permanent_url = $this->feed_url; 831 $this->file =& $file; 832 return true; 833 } 834 return false; 835 } 836 837 /** 838 * Set the raw XML data to parse 839 * 840 * Allows you to use a string of RSS/Atom data instead of a remote feed. 841 * 842 * If you have a feed available as a string in PHP, you can tell SimplePie 843 * to parse that data string instead of a remote feed. Any set feed URL 844 * takes precedence. 845 * 846 * @since 1.0 Beta 3 847 * @param string $data RSS or Atom data as a string. 848 * @see set_feed_url() 849 */ 850 public function set_raw_data($data) 851 { 852 $this->raw_data = $data; 853 } 854 855 /** 856 * Set the default timeout for fetching remote feeds 857 * 858 * This allows you to change the maximum time the feed's server to respond 859 * and send the feed back. 860 * 861 * @since 1.0 Beta 3 862 * @param int $timeout The maximum number of seconds to spend waiting to retrieve a feed. 863 */ 864 public function set_timeout($timeout = 10) 865 { 866 $this->timeout = (int) $timeout; 867 } 868 869 /** 870 * Set custom curl options 871 * 872 * This allows you to change default curl options 873 * 874 * @since 1.0 Beta 3 875 * @param array $curl_options Curl options to add to default settings 876 */ 877 public function set_curl_options(array $curl_options = array()) 878 { 879 $this->curl_options = $curl_options; 880 } 881 882 /** 883 * Force SimplePie to use fsockopen() instead of cURL 884 * 885 * @since 1.0 Beta 3 886 * @param bool $enable Force fsockopen() to be used 887 */ 888 public function force_fsockopen($enable = false) 889 { 890 $this->force_fsockopen = (bool) $enable; 891 } 892 893 /** 894 * Enable/disable caching in SimplePie. 895 * 896 * This option allows you to disable caching all-together in SimplePie. 897 * However, disabling the cache can lead to longer load times. 898 * 899 * @since 1.0 Preview Release 900 * @param bool $enable Enable caching 901 */ 902 public function enable_cache($enable = true) 903 { 904 $this->cache = (bool) $enable; 905 } 906 907 /** 908 * SimplePie to continue to fall back to expired cache, if enabled, when 909 * feed is unavailable. 910 * 911 * This tells SimplePie to ignore any file errors and fall back to cache 912 * instead. This only works if caching is enabled and cached content 913 * still exists. 914 915 * @param bool $enable Force use of cache on fail. 916 */ 917 public function force_cache_fallback($enable = false) 918 { 919 $this->force_cache_fallback= (bool) $enable; 920 } 921 922 /** 923 * Set the length of time (in seconds) that the contents of a feed will be 924 * cached 925 * 926 * @param int $seconds The feed content cache duration 927 */ 928 public function set_cache_duration($seconds = 3600) 929 { 930 $this->cache_duration = (int) $seconds; 931 } 932 933 /** 934 * Set the length of time (in seconds) that the autodiscovered feed URL will 935 * be cached 936 * 937 * @param int $seconds The autodiscovered feed URL cache duration. 938 */ 939 public function set_autodiscovery_cache_duration($seconds = 604800) 940 { 941 $this->autodiscovery_cache_duration = (int) $seconds; 942 } 943 944 /** 945 * Set the file system location where the cached files should be stored 946 * 947 * @param string $location The file system location. 948 */ 949 public function set_cache_location($location = './cache') 950 { 951 $this->cache_location = (string) $location; 952 } 953 954 /** 955 * Return the filename (i.e. hash, without path and without extension) of the file to cache a given URL. 956 * @param string $url The URL of the feed to be cached. 957 * @return string A filename (i.e. hash, without path and without extension). 958 */ 959 public function get_cache_filename($url) 960 { 961 // Append custom parameters to the URL to avoid cache pollution in case of multiple calls with different parameters. 962 $url .= $this->force_feed ? '#force_feed' : ''; 963 $options = array(); 964 if ($this->timeout != 10) 965 { 966 $options[CURLOPT_TIMEOUT] = $this->timeout; 967 } 968 if ($this->useragent !== SIMPLEPIE_USERAGENT) 969 { 970 $options[CURLOPT_USERAGENT] = $this->useragent; 971 } 972 if (!empty($this->curl_options)) 973 { 974 foreach ($this->curl_options as $k => $v) 975 { 976 $options[$k] = $v; 977 } 978 } 979 if (!empty($options)) 980 { 981 ksort($options); 982 $url .= '#' . urlencode(var_export($options, true)); 983 } 984 return call_user_func($this->cache_name_function, $url); 985 } 986 987 /** 988 * Set whether feed items should be sorted into reverse chronological order 989 * 990 * @param bool $enable Sort as reverse chronological order. 991 */ 992 public function enable_order_by_date($enable = true) 993 { 994 $this->order_by_date = (bool) $enable; 995 } 996 997 /** 998 * Set the character encoding used to parse the feed 999 * 1000 * This overrides the encoding reported by the feed, however it will fall 1001 * back to the normal encoding detection if the override fails 1002 * 1003 * @param string $encoding Character encoding 1004 */ 1005 public function set_input_encoding($encoding = false) 1006 { 1007 if ($encoding) 1008 { 1009 $this->input_encoding = (string) $encoding; 1010 } 1011 else 1012 { 1013 $this->input_encoding = false; 1014 } 1015 } 1016 1017 /** 1018 * Set how much feed autodiscovery to do 1019 * 1020 * @see SIMPLEPIE_LOCATOR_NONE 1021 * @see SIMPLEPIE_LOCATOR_AUTODISCOVERY 1022 * @see SIMPLEPIE_LOCATOR_LOCAL_EXTENSION 1023 * @see SIMPLEPIE_LOCATOR_LOCAL_BODY 1024 * @see SIMPLEPIE_LOCATOR_REMOTE_EXTENSION 1025 * @see SIMPLEPIE_LOCATOR_REMOTE_BODY 1026 * @see SIMPLEPIE_LOCATOR_ALL 1027 * @param int $level Feed Autodiscovery Level (level can be a combination of the above constants, see bitwise OR operator) 1028 */ 1029 public function set_autodiscovery_level($level = SIMPLEPIE_LOCATOR_ALL) 1030 { 1031 $this->autodiscovery = (int) $level; 1032 } 1033 1034 /** 1035 * Get the class registry 1036 * 1037 * Use this to override SimplePie's default classes 1038 * @see SimplePie_Registry 1039 * @return SimplePie_Registry 1040 */ 1041 public function &get_registry() 1042 { 1043 return $this->registry; 1044 } 1045 1046 /**#@+ 1047 * Useful when you are overloading or extending SimplePie's default classes. 1048 * 1049 * @deprecated Use {@see get_registry()} instead 1050 * @link http://php.net/manual/en/language.oop5.basic.php#language.oop5.basic.extends PHP5 extends documentation 1051 * @param string $class Name of custom class 1052 * @return boolean True on success, false otherwise 1053 */ 1054 /** 1055 * Set which class SimplePie uses for caching 1056 */ 1057 public function set_cache_class($class = 'SimplePie_Cache') 1058 { 1059 return $this->registry->register('Cache', $class, true); 1060 } 1061 1062 /** 1063 * Set which class SimplePie uses for auto-discovery 1064 */ 1065 public function set_locator_class($class = 'SimplePie_Locator') 1066 { 1067 return $this->registry->register('Locator', $class, true); 1068 } 1069 1070 /** 1071 * Set which class SimplePie uses for XML parsing 1072 */ 1073 public function set_parser_class($class = 'SimplePie_Parser') 1074 { 1075 return $this->registry->register('Parser', $class, true); 1076 } 1077 1078 /** 1079 * Set which class SimplePie uses for remote file fetching 1080 */ 1081 public function set_file_class($class = 'SimplePie_File') 1082 { 1083 return $this->registry->register('File', $class, true); 1084 } 1085 1086 /** 1087 * Set which class SimplePie uses for data sanitization 1088 */ 1089 public function set_sanitize_class($class = 'SimplePie_Sanitize') 1090 { 1091 return $this->registry->register('Sanitize', $class, true); 1092 } 1093 1094 /** 1095 * Set which class SimplePie uses for handling feed items 1096 */ 1097 public function set_item_class($class = 'SimplePie_Item') 1098 { 1099 return $this->registry->register('Item', $class, true); 1100 } 1101 1102 /** 1103 * Set which class SimplePie uses for handling author data 1104 */ 1105 public function set_author_class($class = 'SimplePie_Author') 1106 { 1107 return $this->registry->register('Author', $class, true); 1108 } 1109 1110 /** 1111 * Set which class SimplePie uses for handling category data 1112 */ 1113 public function set_category_class($class = 'SimplePie_Category') 1114 { 1115 return $this->registry->register('Category', $class, true); 1116 } 1117 1118 /** 1119 * Set which class SimplePie uses for feed enclosures 1120 */ 1121 public function set_enclosure_class($class = 'SimplePie_Enclosure') 1122 { 1123 return $this->registry->register('Enclosure', $class, true); 1124 } 1125 1126 /** 1127 * Set which class SimplePie uses for `<media:text>` captions 1128 */ 1129 public function set_caption_class($class = 'SimplePie_Caption') 1130 { 1131 return $this->registry->register('Caption', $class, true); 1132 } 1133 1134 /** 1135 * Set which class SimplePie uses for `<media:copyright>` 1136 */ 1137 public function set_copyright_class($class = 'SimplePie_Copyright') 1138 { 1139 return $this->registry->register('Copyright', $class, true); 1140 } 1141 1142 /** 1143 * Set which class SimplePie uses for `<media:credit>` 1144 */ 1145 public function set_credit_class($class = 'SimplePie_Credit') 1146 { 1147 return $this->registry->register('Credit', $class, true); 1148 } 1149 1150 /** 1151 * Set which class SimplePie uses for `<media:rating>` 1152 */ 1153 public function set_rating_class($class = 'SimplePie_Rating') 1154 { 1155 return $this->registry->register('Rating', $class, true); 1156 } 1157 1158 /** 1159 * Set which class SimplePie uses for `<media:restriction>` 1160 */ 1161 public function set_restriction_class($class = 'SimplePie_Restriction') 1162 { 1163 return $this->registry->register('Restriction', $class, true); 1164 } 1165 1166 /** 1167 * Set which class SimplePie uses for content-type sniffing 1168 */ 1169 public function set_content_type_sniffer_class($class = 'SimplePie_Content_Type_Sniffer') 1170 { 1171 return $this->registry->register('Content_Type_Sniffer', $class, true); 1172 } 1173 1174 /** 1175 * Set which class SimplePie uses item sources 1176 */ 1177 public function set_source_class($class = 'SimplePie_Source') 1178 { 1179 return $this->registry->register('Source', $class, true); 1180 } 1181 /**#@-*/ 1182 1183 /** 1184 * Set the user agent string 1185 * 1186 * @param string $ua New user agent string. 1187 */ 1188 public function set_useragent($ua = SIMPLEPIE_USERAGENT) 1189 { 1190 $this->useragent = (string) $ua; 1191 } 1192 1193 /** 1194 * Set callback function to create cache filename with 1195 * 1196 * @param mixed $function Callback function 1197 */ 1198 public function set_cache_name_function($function = 'md5') 1199 { 1200 if (is_callable($function)) 1201 { 1202 $this->cache_name_function = $function; 1203 } 1204 } 1205 1206 /** 1207 * Set options to make SimplePie as fast as possible. 1208 * 1209 * Forgoes a substantial amount of data sanitization in favor of speed. 1210 * This turns SimplePie into a less clever parser of feeds. 1211 * 1212 * @param bool $set Whether to set them or not. 1213 */ 1214 public function set_stupidly_fast($set = false) 1215 { 1216 if ($set) 1217 { 1218 $this->enable_order_by_date(false); 1219 $this->remove_div(false); 1220 $this->strip_comments(false); 1221 $this->strip_htmltags(false); 1222 $this->strip_attributes(false); 1223 $this->add_attributes(false); 1224 $this->set_image_handler(false); 1225 $this->set_https_domains(array()); 1226 } 1227 } 1228 1229 /** 1230 * Set maximum number of feeds to check with autodiscovery 1231 * 1232 * @param int $max Maximum number of feeds to check 1233 */ 1234 public function set_max_checked_feeds($max = 10) 1235 { 1236 $this->max_checked_feeds = (int) $max; 1237 } 1238 1239 public function remove_div($enable = true) 1240 { 1241 $this->sanitize->remove_div($enable); 1242 } 1243 1244 public function strip_htmltags($tags = '', $encode = null) 1245 { 1246 if ($tags === '') 1247 { 1248 $tags = $this->strip_htmltags; 1249 } 1250 $this->sanitize->strip_htmltags($tags); 1251 if ($encode !== null) 1252 { 1253 $this->sanitize->encode_instead_of_strip($tags); 1254 } 1255 } 1256 1257 public function encode_instead_of_strip($enable = true) 1258 { 1259 $this->sanitize->encode_instead_of_strip($enable); 1260 } 1261 1262 public function strip_attributes($attribs = '') 1263 { 1264 if ($attribs === '') 1265 { 1266 $attribs = $this->strip_attributes; 1267 } 1268 $this->sanitize->strip_attributes($attribs); 1269 } 1270 1271 public function add_attributes($attribs = '') 1272 { 1273 if ($attribs === '') 1274 { 1275 $attribs = $this->add_attributes; 1276 } 1277 $this->sanitize->add_attributes($attribs); 1278 } 1279 1280 /** 1281 * Set the output encoding 1282 * 1283 * Allows you to override SimplePie's output to match that of your webpage. 1284 * This is useful for times when your webpages are not being served as 1285 * UTF-8. This setting will be obeyed by {@see handle_content_type()}, and 1286 * is similar to {@see set_input_encoding()}. 1287 * 1288 * It should be noted, however, that not all character encodings can support 1289 * all characters. If your page is being served as ISO-8859-1 and you try 1290 * to display a Japanese feed, you'll likely see garbled characters. 1291 * Because of this, it is highly recommended to ensure that your webpages 1292 * are served as UTF-8. 1293 * 1294 * The number of supported character encodings depends on whether your web 1295 * host supports {@link http://php.net/mbstring mbstring}, 1296 * {@link http://php.net/iconv iconv}, or both. See 1297 * {@link http://simplepie.org/wiki/faq/Supported_Character_Encodings} for 1298 * more information. 1299 * 1300 * @param string $encoding 1301 */ 1302 public function set_output_encoding($encoding = 'UTF-8') 1303 { 1304 $this->sanitize->set_output_encoding($encoding); 1305 } 1306 1307 public function strip_comments($strip = false) 1308 { 1309 $this->sanitize->strip_comments($strip); 1310 } 1311 1312 /** 1313 * Set element/attribute key/value pairs of HTML attributes 1314 * containing URLs that need to be resolved relative to the feed 1315 * 1316 * Defaults to |a|@href, |area|@href, |blockquote|@cite, |del|@cite, 1317 * |form|@action, |img|@longdesc, |img|@src, |input|@src, |ins|@cite, 1318 * |q|@cite 1319 * 1320 * @since 1.0 1321 * @param array|null $element_attribute Element/attribute key/value pairs, null for default 1322 */ 1323 public function set_url_replacements($element_attribute = null) 1324 { 1325 $this->sanitize->set_url_replacements($element_attribute); 1326 } 1327 1328 /** 1329 * Set the list of domains for which to force HTTPS. 1330 * @see SimplePie_Sanitize::set_https_domains() 1331 * @param array List of HTTPS domains. Example array('biz', 'example.com', 'example.org', 'www.example.net'). 1332 */ 1333 public function set_https_domains($domains = array()) 1334 { 1335 if (is_array($domains)) 1336 { 1337 $this->sanitize->set_https_domains($domains); 1338 } 1339 } 1340 1341 /** 1342 * Set the handler to enable the display of cached images. 1343 * 1344 * @param string $page Web-accessible path to the handler_image.php file. 1345 * @param string $qs The query string that the value should be passed to. 1346 */ 1347 public function set_image_handler($page = false, $qs = 'i') 1348 { 1349 if ($page !== false) 1350 { 1351 $this->sanitize->set_image_handler($page . '?' . $qs . '='); 1352 } 1353 else 1354 { 1355 $this->image_handler = ''; 1356 } 1357 } 1358 1359 /** 1360 * Set the limit for items returned per-feed with multifeeds 1361 * 1362 * @param integer $limit The maximum number of items to return. 1363 */ 1364 public function set_item_limit($limit = 0) 1365 { 1366 $this->item_limit = (int) $limit; 1367 } 1368 1369 /** 1370 * Enable throwing exceptions 1371 * 1372 * @param boolean $enable Should we throw exceptions, or use the old-style error property? 1373 */ 1374 public function enable_exceptions($enable = true) 1375 { 1376 $this->enable_exceptions = $enable; 1377 } 1378 1379 /** 1380 * Initialize the feed object 1381 * 1382 * This is what makes everything happen. Period. This is where all of the 1383 * configuration options get processed, feeds are fetched, cached, and 1384 * parsed, and all of that other good stuff. 1385 * 1386 * @return boolean True if successful, false otherwise 1387 */ 1388 public function init() 1389 { 1390 // Check absolute bare minimum requirements. 1391 if (!extension_loaded('xml') || !extension_loaded('pcre')) 1392 { 1393 $this->error = 'XML or PCRE extensions not loaded!'; 1394 return false; 1395 } 1396 // Then check the xml extension is sane (i.e., libxml 2.7.x issue on PHP < 5.2.9 and libxml 2.7.0 to 2.7.2 on any version) if we don't have xmlreader. 1397 elseif (!extension_loaded('xmlreader')) 1398 { 1399 static $xml_is_sane = null; 1400 if ($xml_is_sane === null) 1401 { 1402 $parser_check = xml_parser_create(); 1403 xml_parse_into_struct($parser_check, '<foo>&</foo>', $values); 1404 xml_parser_free($parser_check); 1405 $xml_is_sane = isset($values[0]['value']); 1406 } 1407 if (!$xml_is_sane) 1408 { 1409 return false; 1410 } 1411 } 1412 1413 // The default sanitize class gets set in the constructor, check if it has 1414 // changed. 1415 if ($this->registry->get_class('Sanitize') !== 'SimplePie_Sanitize') { 1416 $this->sanitize = $this->registry->create('Sanitize'); 1417 } 1418 if (method_exists($this->sanitize, 'set_registry')) 1419 { 1420 $this->sanitize->set_registry($this->registry); 1421 } 1422 1423 // Pass whatever was set with config options over to the sanitizer. 1424 // Pass the classes in for legacy support; new classes should use the registry instead 1425 $this->sanitize->pass_cache_data($this->cache, $this->cache_location, $this->cache_name_function, $this->registry->get_class('Cache')); 1426 $this->sanitize->pass_file_data($this->registry->get_class('File'), $this->timeout, $this->useragent, $this->force_fsockopen, $this->curl_options); 1427 1428 if (!empty($this->multifeed_url)) 1429 { 1430 $i = 0; 1431 $success = 0; 1432 $this->multifeed_objects = array(); 1433 $this->error = array(); 1434 foreach ($this->multifeed_url as $url) 1435 { 1436 $this->multifeed_objects[$i] = clone $this; 1437 $this->multifeed_objects[$i]->set_feed_url($url); 1438 $single_success = $this->multifeed_objects[$i]->init(); 1439 $success |= $single_success; 1440 if (!$single_success) 1441 { 1442 $this->error[$i] = $this->multifeed_objects[$i]->error(); 1443 } 1444 $i++; 1445 } 1446 return (bool) $success; 1447 } 1448 elseif ($this->feed_url === null && $this->raw_data === null) 1449 { 1450 return false; 1451 } 1452 1453 $this->error = null; 1454 $this->data = array(); 1455 $this->check_modified = false; 1456 $this->multifeed_objects = array(); 1457 $cache = false; 1458 1459 if ($this->feed_url !== null) 1460 { 1461 $parsed_feed_url = $this->registry->call('Misc', 'parse_url', array($this->feed_url)); 1462 1463 // Decide whether to enable caching 1464 if ($this->cache && $parsed_feed_url['scheme'] !== '') 1465 { 1466 $filename = $this->get_cache_filename($this->feed_url); 1467 $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, $filename, 'spc')); 1468 } 1469 1470 // Fetch the data via SimplePie_File into $this->raw_data 1471 if (($fetched = $this->fetch_data($cache)) === true) 1472 { 1473 return true; 1474 } 1475 elseif ($fetched === false) { 1476 return false; 1477 } 1478 1479 list($headers, $sniffed) = $fetched; 1480 } 1481 1482 // Empty response check 1483 if(empty($this->raw_data)){ 1484 $this->error = "A feed could not be found at `$this->feed_url`. Empty body."; 1485 $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); 1486 return false; 1487 } 1488 1489 // Set up array of possible encodings 1490 $encodings = array(); 1491 1492 // First check to see if input has been overridden. 1493 if ($this->input_encoding !== false) 1494 { 1495 $encodings[] = strtoupper($this->input_encoding); 1496 } 1497 1498 $application_types = array('application/xml', 'application/xml-dtd', 'application/xml-external-parsed-entity'); 1499 $text_types = array('text/xml', 'text/xml-external-parsed-entity'); 1500 1501 // RFC 3023 (only applies to sniffed content) 1502 if (isset($sniffed)) 1503 { 1504 if (in_array($sniffed, $application_types) || substr($sniffed, 0, 12) === 'application/' && substr($sniffed, -4) === '+xml') 1505 { 1506 if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset)) 1507 { 1508 $encodings[] = strtoupper($charset[1]); 1509 } 1510 $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry))); 1511 $encodings[] = 'UTF-8'; 1512 } 1513 elseif (in_array($sniffed, $text_types) || substr($sniffed, 0, 5) === 'text/' && substr($sniffed, -4) === '+xml') 1514 { 1515 if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset)) 1516 { 1517 $encodings[] = strtoupper($charset[1]); 1518 } 1519 $encodings[] = 'US-ASCII'; 1520 } 1521 // Text MIME-type default 1522 elseif (substr($sniffed, 0, 5) === 'text/') 1523 { 1524 $encodings[] = 'UTF-8'; 1525 } 1526 } 1527 1528 // Fallback to XML 1.0 Appendix F.1/UTF-8/ISO-8859-1 1529 $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry))); 1530 $encodings[] = 'UTF-8'; 1531 $encodings[] = 'ISO-8859-1'; 1532 1533 // There's no point in trying an encoding twice 1534 $encodings = array_unique($encodings); 1535 1536 // Loop through each possible encoding, till we return something, or run out of possibilities 1537 foreach ($encodings as $encoding) 1538 { 1539 // Change the encoding to UTF-8 (as we always use UTF-8 internally) 1540 if ($utf8_data = $this->registry->call('Misc', 'change_encoding', array($this->raw_data, $encoding, 'UTF-8'))) 1541 { 1542 // Create new parser 1543 $parser = $this->registry->create('Parser'); 1544 1545 // If it's parsed fine 1546 if ($parser->parse($utf8_data, 'UTF-8', $this->permanent_url)) 1547 { 1548 $this->data = $parser->get_data(); 1549 if (!($this->get_type() & ~SIMPLEPIE_TYPE_NONE)) 1550 { 1551 $this->error = "A feed could not be found at `$this->feed_url`. This does not appear to be a valid RSS or Atom feed."; 1552 $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); 1553 return false; 1554 } 1555 1556 if (isset($headers)) 1557 { 1558 $this->data['headers'] = $headers; 1559 } 1560 $this->data['build'] = SIMPLEPIE_BUILD; 1561 1562 // Cache the file if caching is enabled 1563 if ($cache && !$cache->save($this)) 1564 { 1565 trigger_error("$this->cache_location is not writable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING); 1566 } 1567 return true; 1568 } 1569 } 1570 } 1571 1572 if (isset($parser)) 1573 { 1574 // We have an error, just set SimplePie_Misc::error to it and quit 1575 $this->error = $this->feed_url; 1576 $this->error .= sprintf(' is invalid XML, likely due to invalid characters. XML error: %s at line %d, column %d', $parser->get_error_string(), $parser->get_current_line(), $parser->get_current_column()); 1577 } 1578 else 1579 { 1580 $this->error = 'The data could not be converted to UTF-8.'; 1581 if (!extension_loaded('mbstring') && !extension_loaded('iconv') && !class_exists('\UConverter')) { 1582 $this->error .= ' You MUST have either the iconv, mbstring or intl (PHP 5.5+) extension installed and enabled.'; 1583 } else { 1584 $missingExtensions = array(); 1585 if (!extension_loaded('iconv')) { 1586 $missingExtensions[] = 'iconv'; 1587 } 1588 if (!extension_loaded('mbstring')) { 1589 $missingExtensions[] = 'mbstring'; 1590 } 1591 if (!class_exists('\UConverter')) { 1592 $missingExtensions[] = 'intl (PHP 5.5+)'; 1593 } 1594 $this->error .= ' Try installing/enabling the ' . implode(' or ', $missingExtensions) . ' extension.'; 1595 } 1596 } 1597 1598 $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); 1599 1600 return false; 1601 } 1602 1603 /** 1604 * Fetch the data via SimplePie_File 1605 * 1606 * If the data is already cached, attempt to fetch it from there instead 1607 * @param SimplePie_Cache_Base|false $cache Cache handler, or false to not load from the cache 1608 * @return array|true Returns true if the data was loaded from the cache, or an array of HTTP headers and sniffed type 1609 */ 1610 protected function fetch_data(&$cache) 1611 { 1612 // If it's enabled, use the cache 1613 if ($cache) 1614 { 1615 // Load the Cache 1616 $this->data = $cache->load(); 1617 if (!empty($this->data)) 1618 { 1619 // If the cache is for an outdated build of SimplePie 1620 if (!isset($this->data['build']) || $this->data['build'] !== SIMPLEPIE_BUILD) 1621 { 1622 $cache->unlink(); 1623 $this->data = array(); 1624 } 1625 // If we've hit a collision just rerun it with caching disabled 1626 elseif (isset($this->data['url']) && $this->data['url'] !== $this->feed_url) 1627 { 1628 $cache = false; 1629 $this->data = array(); 1630 } 1631 // If we've got a non feed_url stored (if the page isn't actually a feed, or is a redirect) use that URL. 1632 elseif (isset($this->data['feed_url'])) 1633 { 1634 // If the autodiscovery cache is still valid use it. 1635 if ($cache->mtime() + $this->autodiscovery_cache_duration > time()) 1636 { 1637 // Do not need to do feed autodiscovery yet. 1638 if ($this->data['feed_url'] !== $this->data['url']) 1639 { 1640 $this->set_feed_url($this->data['feed_url']); 1641 return $this->init(); 1642 } 1643 1644 $cache->unlink(); 1645 $this->data = array(); 1646 } 1647 } 1648 // Check if the cache has been updated 1649 elseif ($cache->mtime() + $this->cache_duration < time()) 1650 { 1651 // Want to know if we tried to send last-modified and/or etag headers 1652 // when requesting this file. (Note that it's up to the file to 1653 // support this, but we don't always send the headers either.) 1654 $this->check_modified = true; 1655 if (isset($this->data['headers']['last-modified']) || isset($this->data['headers']['etag'])) 1656 { 1657 $headers = array( 1658 'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1', 1659 ); 1660 if (isset($this->data['headers']['last-modified'])) 1661 { 1662 $headers['if-modified-since'] = $this->data['headers']['last-modified']; 1663 } 1664 if (isset($this->data['headers']['etag'])) 1665 { 1666 $headers['if-none-match'] = $this->data['headers']['etag']; 1667 } 1668 1669 $file = $this->registry->create('File', array($this->feed_url, $this->timeout/10, 5, $headers, $this->useragent, $this->force_fsockopen, $this->curl_options)); 1670 $this->status_code = $file->status_code; 1671 1672 if ($file->success) 1673 { 1674 if ($file->status_code === 304) 1675 { 1676 // Set raw_data to false here too, to signify that the cache 1677 // is still valid. 1678 $this->raw_data = false; 1679 $cache->touch(); 1680 return true; 1681 } 1682 } 1683 else 1684 { 1685 $this->check_modified = false; 1686 if($this->force_cache_fallback) 1687 { 1688 $cache->touch(); 1689 return true; 1690 } 1691 1692 unset($file); 1693 } 1694 } 1695 } 1696 // If the cache is still valid, just return true 1697 else 1698 { 1699 $this->raw_data = false; 1700 return true; 1701 } 1702 } 1703 // If the cache is empty, delete it 1704 else 1705 { 1706 $cache->unlink(); 1707 $this->data = array(); 1708 } 1709 } 1710 // If we don't already have the file (it'll only exist if we've opened it to check if the cache has been modified), open it. 1711 if (!isset($file)) 1712 { 1713 if ($this->file instanceof SimplePie_File && $this->file->url === $this->feed_url) 1714 { 1715 $file =& $this->file; 1716 } 1717 else 1718 { 1719 $headers = array( 1720 'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1', 1721 ); 1722 $file = $this->registry->create('File', array($this->feed_url, $this->timeout, 5, $headers, $this->useragent, $this->force_fsockopen, $this->curl_options)); 1723 } 1724 } 1725 $this->status_code = $file->status_code; 1726 1727 // If the file connection has an error, set SimplePie::error to that and quit 1728 if (!$file->success && !($file->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($file->status_code === 200 || $file->status_code > 206 && $file->status_code < 300))) 1729 { 1730 $this->error = $file->error; 1731 return !empty($this->data); 1732 } 1733 1734 if (!$this->force_feed) 1735 { 1736 // Check if the supplied URL is a feed, if it isn't, look for it. 1737 $locate = $this->registry->create('Locator', array(&$file, $this->timeout, $this->useragent, $this->max_checked_feeds, $this->force_fsockopen, $this->curl_options)); 1738 1739 if (!$locate->is_feed($file)) 1740 { 1741 $copyStatusCode = $file->status_code; 1742 $copyContentType = $file->headers['content-type']; 1743 try 1744 { 1745 $microformats = false; 1746 if (class_exists('DOMXpath') && function_exists('Mf2\parse')) { 1747 $doc = new DOMDocument(); 1748 @$doc->loadHTML($file->body); 1749 $xpath = new DOMXpath($doc); 1750 // Check for both h-feed and h-entry, as both a feed with no entries 1751 // and a list of entries without an h-feed wrapper are both valid. 1752 $query = '//*[contains(concat(" ", @class, " "), " h-feed ") or '. 1753 'contains(concat(" ", @class, " "), " h-entry ")]'; 1754 $result = $xpath->query($query); 1755 $microformats = $result->length !== 0; 1756 } 1757 // Now also do feed discovery, but if microformats were found don't 1758 // overwrite the current value of file. 1759 $discovered = $locate->find($this->autodiscovery, 1760 $this->all_discovered_feeds); 1761 if ($microformats) 1762 { 1763 if ($hub = $locate->get_rel_link('hub')) 1764 { 1765 $self = $locate->get_rel_link('self'); 1766 $this->store_links($file, $hub, $self); 1767 } 1768 // Push the current file onto all_discovered feeds so the user can 1769 // be shown this as one of the options. 1770 if (isset($this->all_discovered_feeds)) { 1771 $this->all_discovered_feeds[] = $file; 1772 } 1773 } 1774 else 1775 { 1776 if ($discovered) 1777 { 1778 $file = $discovered; 1779 } 1780 else 1781 { 1782 // We need to unset this so that if SimplePie::set_file() has 1783 // been called that object is untouched 1784 unset($file); 1785 $this->error = "A feed could not be found at `$this->feed_url`; the status code is `$copyStatusCode` and content-type is `$copyContentType`"; 1786 $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); 1787 return false; 1788 } 1789 } 1790 } 1791 catch (SimplePie_Exception $e) 1792 { 1793 // We need to unset this so that if SimplePie::set_file() has been called that object is untouched 1794 unset($file); 1795 // This is usually because DOMDocument doesn't exist 1796 $this->error = $e->getMessage(); 1797 $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, $e->getFile(), $e->getLine())); 1798 return false; 1799 } 1800 if ($cache) 1801 { 1802 $this->data = array('url' => $this->feed_url, 'feed_url' => $file->url, 'build' => SIMPLEPIE_BUILD); 1803 if (!$cache->save($this)) 1804 { 1805 trigger_error("$this->cache_location is not writable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING); 1806 } 1807 $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, call_user_func($this->cache_name_function, $file->url), 'spc')); 1808 } 1809 } 1810 $this->feed_url = $file->url; 1811 $locate = null; 1812 } 1813 1814 $this->raw_data = $file->body; 1815 $this->permanent_url = $file->permanent_url; 1816 $headers = $file->headers; 1817 $sniffer = $this->registry->create('Content_Type_Sniffer', array(&$file)); 1818 $sniffed = $sniffer->get_type(); 1819 1820 return array($headers, $sniffed); 1821 } 1822 1823 /** 1824 * Get the error message for the occurred error 1825 * 1826 * @return string|array Error message, or array of messages for multifeeds 1827 */ 1828 public function error() 1829 { 1830 return $this->error; 1831 } 1832 1833 /** 1834 * Get the last HTTP status code 1835 * 1836 * @return int Status code 1837 */ 1838 public function status_code() 1839 { 1840 return $this->status_code; 1841 } 1842 1843 /** 1844 * Get the raw XML 1845 * 1846 * This is the same as the old `$feed->enable_xml_dump(true)`, but returns 1847 * the data instead of printing it. 1848 * 1849 * @return string|boolean Raw XML data, false if the cache is used 1850 */ 1851 public function get_raw_data() 1852 { 1853 return $this->raw_data; 1854 } 1855 1856 /** 1857 * Get the character encoding used for output 1858 * 1859 * @since Preview Release 1860 * @return string 1861 */ 1862 public function get_encoding() 1863 { 1864 return $this->sanitize->output_encoding; 1865 } 1866 1867 /** 1868 * Send the Content-Type header with correct encoding 1869 * 1870 * This method ensures that the SimplePie-enabled page is being served with 1871 * the correct {@link http://www.iana.org/assignments/media-types/ mime-type} 1872 * and character encoding HTTP headers (character encoding determined by the 1873 * {@see set_output_encoding} config option). 1874 * 1875 * This won't work properly if any content or whitespace has already been 1876 * sent to the browser, because it relies on PHP's 1877 * {@link http://php.net/header header()} function, and these are the 1878 * circumstances under which the function works. 1879 * 1880 * Because it's setting these settings for the entire page (as is the nature 1881 * of HTTP headers), this should only be used once per page (again, at the 1882 * top). 1883 * 1884 * @param string $mime MIME type to serve the page as 1885 */ 1886 public function handle_content_type($mime = 'text/html') 1887 { 1888 if (!headers_sent()) 1889 { 1890 $header = "Content-Type: $mime;"; 1891 if ($this->get_encoding()) 1892 { 1893 $header .= ' charset=' . $this->get_encoding(); 1894 } 1895 else 1896 { 1897 $header .= ' charset=UTF-8'; 1898 } 1899 header($header); 1900 } 1901 } 1902 1903 /** 1904 * Get the type of the feed 1905 * 1906 * This returns a SIMPLEPIE_TYPE_* constant, which can be tested against 1907 * using {@link http://php.net/language.operators.bitwise bitwise operators} 1908 * 1909 * @since 0.8 (usage changed to using constants in 1.0) 1910 * @see SIMPLEPIE_TYPE_NONE Unknown. 1911 * @see SIMPLEPIE_TYPE_RSS_090 RSS 0.90. 1912 * @see SIMPLEPIE_TYPE_RSS_091_NETSCAPE RSS 0.91 (Netscape). 1913 * @see SIMPLEPIE_TYPE_RSS_091_USERLAND RSS 0.91 (Userland). 1914 * @see SIMPLEPIE_TYPE_RSS_091 RSS 0.91. 1915 * @see SIMPLEPIE_TYPE_RSS_092 RSS 0.92. 1916 * @see SIMPLEPIE_TYPE_RSS_093 RSS 0.93. 1917 * @see SIMPLEPIE_TYPE_RSS_094 RSS 0.94. 1918 * @see SIMPLEPIE_TYPE_RSS_10 RSS 1.0. 1919 * @see SIMPLEPIE_TYPE_RSS_20 RSS 2.0.x. 1920 * @see SIMPLEPIE_TYPE_RSS_RDF RDF-based RSS. 1921 * @see SIMPLEPIE_TYPE_RSS_SYNDICATION Non-RDF-based RSS (truly intended as syndication format). 1922 * @see SIMPLEPIE_TYPE_RSS_ALL Any version of RSS. 1923 * @see SIMPLEPIE_TYPE_ATOM_03 Atom 0.3. 1924 * @see SIMPLEPIE_TYPE_ATOM_10 Atom 1.0. 1925 * @see SIMPLEPIE_TYPE_ATOM_ALL Any version of Atom. 1926 * @see SIMPLEPIE_TYPE_ALL Any known/supported feed type. 1927 * @return int SIMPLEPIE_TYPE_* constant 1928 */ 1929 public function get_type() 1930 { 1931 if (!isset($this->data['type'])) 1932 { 1933 $this->data['type'] = SIMPLEPIE_TYPE_ALL; 1934 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'])) 1935 { 1936 $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_10; 1937 } 1938 elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'])) 1939 { 1940 $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_03; 1941 } 1942 elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'])) 1943 { 1944 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['channel']) 1945 || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['image']) 1946 || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['item']) 1947 || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['textinput'])) 1948 { 1949 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_10; 1950 } 1951 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['channel']) 1952 || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['image']) 1953 || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['item']) 1954 || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['textinput'])) 1955 { 1956 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_090; 1957 } 1958 } 1959 elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'])) 1960 { 1961 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_ALL; 1962 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version'])) 1963 { 1964 switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version'])) 1965 { 1966 case '0.91': 1967 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091; 1968 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data'])) 1969 { 1970 switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data'])) 1971 { 1972 case '0': 1973 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_NETSCAPE; 1974 break; 1975 1976 case '24': 1977 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_USERLAND; 1978 break; 1979 } 1980 } 1981 break; 1982 1983 case '0.92': 1984 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_092; 1985 break; 1986 1987 case '0.93': 1988 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_093; 1989 break; 1990 1991 case '0.94': 1992 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_094; 1993 break; 1994 1995 case '2.0': 1996 $this->data['type'] &= SIMPLEPIE_TYPE_RSS_20; 1997 break; 1998 } 1999 } 2000 } 2001 else 2002 { 2003 $this->data['type'] = SIMPLEPIE_TYPE_NONE; 2004 } 2005 } 2006 return $this->data['type']; 2007 } 2008 2009 /** 2010 * Get the URL for the feed 2011 * 2012 * When the 'permanent' mode is enabled, returns the original feed URL, 2013 * except in the case of an `HTTP 301 Moved Permanently` status response, 2014 * in which case the location of the first redirection is returned. 2015 * 2016 * When the 'permanent' mode is disabled (default), 2017 * may or may not be different from the URL passed to {@see set_feed_url()}, 2018 * depending on whether auto-discovery was used, and whether there were 2019 * any redirects along the way. 2020 * 2021 * @since Preview Release (previously called `get_feed_url()` since SimplePie 0.8.) 2022 * @todo Support <itunes:new-feed-url> 2023 * @todo Also, |atom:link|@rel=self 2024 * @param bool $permanent Permanent mode to return only the original URL or the first redirection 2025 * iff it is a 301 redirection 2026 * @return string|null 2027 */ 2028 public function subscribe_url($permanent = false) 2029 { 2030 if ($permanent) 2031 { 2032 if ($this->permanent_url !== null) 2033 { 2034 // sanitize encodes ampersands which are required when used in a url. 2035 return str_replace('&', '&', 2036 $this->sanitize($this->permanent_url, 2037 SIMPLEPIE_CONSTRUCT_IRI)); 2038 } 2039 } 2040 else 2041 { 2042 if ($this->feed_url !== null) 2043 { 2044 return str_replace('&', '&', 2045 $this->sanitize($this->feed_url, 2046 SIMPLEPIE_CONSTRUCT_IRI)); 2047 } 2048 } 2049 return null; 2050 } 2051 2052 /** 2053 * Get data for an feed-level element 2054 * 2055 * This method allows you to get access to ANY element/attribute that is a 2056 * sub-element of the opening feed tag. 2057 * 2058 * The return value is an indexed array of elements matching the given 2059 * namespace and tag name. Each element has `attribs`, `data` and `child` 2060 * subkeys. For `attribs` and `child`, these contain namespace subkeys. 2061 * `attribs` then has one level of associative name => value data (where 2062 * `value` is a string) after the namespace. `child` has tag-indexed keys 2063 * after the namespace, each member of which is an indexed array matching 2064 * this same format. 2065 * 2066 * For example: 2067 * <pre> 2068 * // This is probably a bad example because we already support 2069 * // <media:content> natively, but it shows you how to parse through 2070 * // the nodes. 2071 * $group = $item->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group'); 2072 * $content = $group[0]['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']; 2073 * $file = $content[0]['attribs']['']['url']; 2074 * echo $file; 2075 * </pre> 2076 * 2077 * @since 1.0 2078 * @see http://simplepie.org/wiki/faq/supported_xml_namespaces 2079 * @param string $namespace The URL of the XML namespace of the elements you're trying to access 2080 * @param string $tag Tag name 2081 * @return array 2082 */ 2083 public function get_feed_tags($namespace, $tag) 2084 { 2085 $type = $this->get_type(); 2086 if ($type & SIMPLEPIE_TYPE_ATOM_10) 2087 { 2088 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag])) 2089 { 2090 return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag]; 2091 } 2092 } 2093 if ($type & SIMPLEPIE_TYPE_ATOM_03) 2094 { 2095 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag])) 2096 { 2097 return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag]; 2098 } 2099 } 2100 if ($type & SIMPLEPIE_TYPE_RSS_RDF) 2101 { 2102 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag])) 2103 { 2104 return $this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag]; 2105 } 2106 } 2107 if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) 2108 { 2109 if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag])) 2110 { 2111 return $this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag]; 2112 } 2113 } 2114 return null; 2115 } 2116 2117 /** 2118 * Get data for an channel-level element 2119 * 2120 * This method allows you to get access to ANY element/attribute in the 2121 * channel/header section of the feed. 2122 * 2123 * See {@see SimplePie::get_feed_tags()} for a description of the return value 2124 * 2125 * @since 1.0 2126 * @see http://simplepie.org/wiki/faq/supported_xml_namespaces 2127 * @param string $namespace The URL of the XML namespace of the elements you're trying to access 2128 * @param string $tag Tag name 2129 * @return array 2130 */ 2131 public function get_channel_tags($namespace, $tag) 2132 { 2133 $type = $this->get_type(); 2134 if ($type & SIMPLEPIE_TYPE_ATOM_ALL) 2135 { 2136 if ($return = $this->get_feed_tags($namespace, $tag)) 2137 { 2138 return $return; 2139 } 2140 } 2141 if ($type & SIMPLEPIE_TYPE_RSS_10) 2142 { 2143 if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'channel')) 2144 { 2145 if (isset($channel[0]['child'][$namespace][$tag])) 2146 { 2147 return $channel[0]['child'][$namespace][$tag]; 2148 } 2149 } 2150 } 2151 if ($type & SIMPLEPIE_TYPE_RSS_090) 2152 { 2153 if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'channel')) 2154 { 2155 if (isset($channel[0]['child'][$namespace][$tag])) 2156 { 2157 return $channel[0]['child'][$namespace][$tag]; 2158 } 2159 } 2160 } 2161 if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) 2162 { 2163 if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'channel')) 2164 { 2165 if (isset($channel[0]['child'][$namespace][$tag])) 2166 { 2167 return $channel[0]['child'][$namespace][$tag]; 2168 } 2169 } 2170 } 2171 return null; 2172 } 2173 2174 /** 2175 * Get data for an channel-level element 2176 * 2177 * This method allows you to get access to ANY element/attribute in the 2178 * image/logo section of the feed. 2179 * 2180 * See {@see SimplePie::get_feed_tags()} for a description of the return value 2181 * 2182 * @since 1.0 2183 * @see http://simplepie.org/wiki/faq/supported_xml_namespaces 2184 * @param string $namespace The URL of the XML namespace of the elements you're trying to access 2185 * @param string $tag Tag name 2186 * @return array 2187 */ 2188 public function get_image_tags($namespace, $tag) 2189 { 2190 $type = $this->get_type(); 2191 if ($type & SIMPLEPIE_TYPE_RSS_10) 2192 { 2193 if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'image')) 2194 { 2195 if (isset($image[0]['child'][$namespace][$tag])) 2196 { 2197 return $image[0]['child'][$namespace][$tag]; 2198 } 2199 } 2200 } 2201 if ($type & SIMPLEPIE_TYPE_RSS_090) 2202 { 2203 if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'image')) 2204 { 2205 if (isset($image[0]['child'][$namespace][$tag])) 2206 { 2207 return $image[0]['child'][$namespace][$tag]; 2208 } 2209 } 2210 } 2211 if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) 2212 { 2213 if ($image = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'image')) 2214 { 2215 if (isset($image[0]['child'][$namespace][$tag])) 2216 { 2217 return $image[0]['child'][$namespace][$tag]; 2218 } 2219 } 2220 } 2221 return null; 2222 } 2223 2224 /** 2225 * Get the base URL value from the feed 2226 * 2227 * Uses `<xml:base>` if available, otherwise uses the first link in the 2228 * feed, or failing that, the URL of the feed itself. 2229 * 2230 * @see get_link 2231 * @see subscribe_url 2232 * 2233 * @param array $element 2234 * @return string 2235 */ 2236 public function get_base($element = array()) 2237 { 2238 if (!($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION) && !empty($element['xml_base_explicit']) && isset($element['xml_base'])) 2239 { 2240 return $element['xml_base']; 2241 } 2242 elseif ($this->get_link() !== null) 2243 { 2244 return $this->get_link(); 2245 } 2246 2247 return $this->subscribe_url(); 2248 } 2249 2250 /** 2251 * Sanitize feed data 2252 * 2253 * @access private 2254 * @see SimplePie_Sanitize::sanitize() 2255 * @param string $data Data to sanitize 2256 * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants 2257 * @param string $base Base URL to resolve URLs against 2258 * @return string Sanitized data 2259 */ 2260 public function sanitize($data, $type, $base = '') 2261 { 2262 try 2263 { 2264 return $this->sanitize->sanitize($data, $type, $base); 2265 } 2266 catch (SimplePie_Exception $e) 2267 { 2268 if (!$this->enable_exceptions) 2269 { 2270 $this->error = $e->getMessage(); 2271 $this->registry->call('Misc', 'error', array($this->error, E_USER_WARNING, $e->getFile(), $e->getLine())); 2272 return ''; 2273 } 2274 2275 throw $e; 2276 } 2277 } 2278 2279 /** 2280 * Get the title of the feed 2281 * 2282 * Uses `<atom:title>`, `<title>` or `<dc:title>` 2283 * 2284 * @since 1.0 (previously called `get_feed_title` since 0.8) 2285 * @return string|null 2286 */ 2287 public function get_title() 2288 { 2289 if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title')) 2290 { 2291 return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 2292 } 2293 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title')) 2294 { 2295 return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 2296 } 2297 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title')) 2298 { 2299 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 2300 } 2301 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title')) 2302 { 2303 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 2304 } 2305 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title')) 2306 { 2307 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 2308 } 2309 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title')) 2310 { 2311 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2312 } 2313 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title')) 2314 { 2315 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2316 } 2317 2318 return null; 2319 } 2320 2321 /** 2322 * Get a category for the feed 2323 * 2324 * @since Unknown 2325 * @param int $key The category that you want to return. Remember that arrays begin with 0, not 1 2326 * @return SimplePie_Category|null 2327 */ 2328 public function get_category($key = 0) 2329 { 2330 $categories = $this->get_categories(); 2331 if (isset($categories[$key])) 2332 { 2333 return $categories[$key]; 2334 } 2335 2336 return null; 2337 } 2338 2339 /** 2340 * Get all categories for the feed 2341 * 2342 * Uses `<atom:category>`, `<category>` or `<dc:subject>` 2343 * 2344 * @since Unknown 2345 * @return array|null List of {@see SimplePie_Category} objects 2346 */ 2347 public function get_categories() 2348 { 2349 $categories = array(); 2350 2351 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category) 2352 { 2353 $term = null; 2354 $scheme = null; 2355 $label = null; 2356 if (isset($category['attribs']['']['term'])) 2357 { 2358 $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT); 2359 } 2360 if (isset($category['attribs']['']['scheme'])) 2361 { 2362 $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); 2363 } 2364 if (isset($category['attribs']['']['label'])) 2365 { 2366 $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); 2367 } 2368 $categories[] = $this->registry->create('Category', array($term, $scheme, $label)); 2369 } 2370 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category) 2371 { 2372 // This is really the label, but keep this as the term also for BC. 2373 // Label will also work on retrieving because that falls back to term. 2374 $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2375 if (isset($category['attribs']['']['domain'])) 2376 { 2377 $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT); 2378 } 2379 else 2380 { 2381 $scheme = null; 2382 } 2383 $categories[] = $this->registry->create('Category', array($term, $scheme, null)); 2384 } 2385 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category) 2386 { 2387 $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 2388 } 2389 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category) 2390 { 2391 $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 2392 } 2393 2394 if (!empty($categories)) 2395 { 2396 return array_unique($categories); 2397 } 2398 2399 return null; 2400 } 2401 2402 /** 2403 * Get an author for the feed 2404 * 2405 * @since 1.1 2406 * @param int $key The author that you want to return. Remember that arrays begin with 0, not 1 2407 * @return SimplePie_Author|null 2408 */ 2409 public function get_author($key = 0) 2410 { 2411 $authors = $this->get_authors(); 2412 if (isset($authors[$key])) 2413 { 2414 return $authors[$key]; 2415 } 2416 2417 return null; 2418 } 2419 2420 /** 2421 * Get all authors for the feed 2422 * 2423 * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>` 2424 * 2425 * @since 1.1 2426 * @return array|null List of {@see SimplePie_Author} objects 2427 */ 2428 public function get_authors() 2429 { 2430 $authors = array(); 2431 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author) 2432 { 2433 $name = null; 2434 $uri = null; 2435 $email = null; 2436 if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) 2437 { 2438 $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2439 } 2440 if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) 2441 { 2442 $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); 2443 } 2444 if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) 2445 { 2446 $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2447 } 2448 if ($name !== null || $email !== null || $uri !== null) 2449 { 2450 $authors[] = $this->registry->create('Author', array($name, $uri, $email)); 2451 } 2452 } 2453 if ($author = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author')) 2454 { 2455 $name = null; 2456 $url = null; 2457 $email = null; 2458 if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) 2459 { 2460 $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2461 } 2462 if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) 2463 { 2464 $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); 2465 } 2466 if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) 2467 { 2468 $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2469 } 2470 if ($name !== null || $email !== null || $url !== null) 2471 { 2472 $authors[] = $this->registry->create('Author', array($name, $url, $email)); 2473 } 2474 } 2475 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author) 2476 { 2477 $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 2478 } 2479 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author) 2480 { 2481 $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 2482 } 2483 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author) 2484 { 2485 $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 2486 } 2487 2488 if (!empty($authors)) 2489 { 2490 return array_unique($authors); 2491 } 2492 2493 return null; 2494 } 2495 2496 /** 2497 * Get a contributor for the feed 2498 * 2499 * @since 1.1 2500 * @param int $key The contrbutor that you want to return. Remember that arrays begin with 0, not 1 2501 * @return SimplePie_Author|null 2502 */ 2503 public function get_contributor($key = 0) 2504 { 2505 $contributors = $this->get_contributors(); 2506 if (isset($contributors[$key])) 2507 { 2508 return $contributors[$key]; 2509 } 2510 2511 return null; 2512 } 2513 2514 /** 2515 * Get all contributors for the feed 2516 * 2517 * Uses `<atom:contributor>` 2518 * 2519 * @since 1.1 2520 * @return array|null List of {@see SimplePie_Author} objects 2521 */ 2522 public function get_contributors() 2523 { 2524 $contributors = array(); 2525 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor) 2526 { 2527 $name = null; 2528 $uri = null; 2529 $email = null; 2530 if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) 2531 { 2532 $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2533 } 2534 if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) 2535 { 2536 $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); 2537 } 2538 if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) 2539 { 2540 $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2541 } 2542 if ($name !== null || $email !== null || $uri !== null) 2543 { 2544 $contributors[] = $this->registry->create('Author', array($name, $uri, $email)); 2545 } 2546 } 2547 foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor) 2548 { 2549 $name = null; 2550 $url = null; 2551 $email = null; 2552 if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) 2553 { 2554 $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2555 } 2556 if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) 2557 { 2558 $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); 2559 } 2560 if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) 2561 { 2562 $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2563 } 2564 if ($name !== null || $email !== null || $url !== null) 2565 { 2566 $contributors[] = $this->registry->create('Author', array($name, $url, $email)); 2567 } 2568 } 2569 2570 if (!empty($contributors)) 2571 { 2572 return array_unique($contributors); 2573 } 2574 2575 return null; 2576 } 2577 2578 /** 2579 * Get a single link for the feed 2580 * 2581 * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8) 2582 * @param int $key The link that you want to return. Remember that arrays begin with 0, not 1 2583 * @param string $rel The relationship of the link to return 2584 * @return string|null Link URL 2585 */ 2586 public function get_link($key = 0, $rel = 'alternate') 2587 { 2588 $links = $this->get_links($rel); 2589 if (isset($links[$key])) 2590 { 2591 return $links[$key]; 2592 } 2593 2594 return null; 2595 } 2596 2597 /** 2598 * Get the permalink for the item 2599 * 2600 * Returns the first link available with a relationship of "alternate". 2601 * Identical to {@see get_link()} with key 0 2602 * 2603 * @see get_link 2604 * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8) 2605 * @internal Added for parity between the parent-level and the item/entry-level. 2606 * @return string|null Link URL 2607 */ 2608 public function get_permalink() 2609 { 2610 return $this->get_link(0); 2611 } 2612 2613 /** 2614 * Get all links for the feed 2615 * 2616 * Uses `<atom:link>` or `<link>` 2617 * 2618 * @since Beta 2 2619 * @param string $rel The relationship of links to return 2620 * @return array|null Links found for the feed (strings) 2621 */ 2622 public function get_links($rel = 'alternate') 2623 { 2624 if (!isset($this->data['links'])) 2625 { 2626 $this->data['links'] = array(); 2627 if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link')) 2628 { 2629 foreach ($links as $link) 2630 { 2631 if (isset($link['attribs']['']['href'])) 2632 { 2633 $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; 2634 $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); 2635 } 2636 } 2637 } 2638 if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link')) 2639 { 2640 foreach ($links as $link) 2641 { 2642 if (isset($link['attribs']['']['href'])) 2643 { 2644 $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; 2645 $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); 2646 2647 } 2648 } 2649 } 2650 if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link')) 2651 { 2652 $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); 2653 } 2654 if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link')) 2655 { 2656 $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); 2657 } 2658 if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link')) 2659 { 2660 $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); 2661 } 2662 2663 $keys = array_keys($this->data['links']); 2664 foreach ($keys as $key) 2665 { 2666 if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key))) 2667 { 2668 if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key])) 2669 { 2670 $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]); 2671 $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]; 2672 } 2673 else 2674 { 2675 $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key]; 2676 } 2677 } 2678 elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY) 2679 { 2680 $this->data['links'][substr($key, 41)] =& $this->data['links'][$key]; 2681 } 2682 $this->data['links'][$key] = array_unique($this->data['links'][$key]); 2683 } 2684 } 2685 2686 if (isset($this->data['headers']['link'])) 2687 { 2688 $link_headers = $this->data['headers']['link']; 2689 if (is_string($link_headers)) { 2690 $link_headers = array($link_headers); 2691 } 2692 $matches = preg_filter('/<([^>]+)>; rel='.preg_quote($rel).'/', '$1', $link_headers); 2693 if (!empty($matches)) { 2694 return $matches; 2695 } 2696 } 2697 2698 if (isset($this->data['links'][$rel])) 2699 { 2700 return $this->data['links'][$rel]; 2701 } 2702 2703 return null; 2704 } 2705 2706 public function get_all_discovered_feeds() 2707 { 2708 return $this->all_discovered_feeds; 2709 } 2710 2711 /** 2712 * Get the content for the item 2713 * 2714 * Uses `<atom:subtitle>`, `<atom:tagline>`, `<description>`, 2715 * `<dc:description>`, `<itunes:summary>` or `<itunes:subtitle>` 2716 * 2717 * @since 1.0 (previously called `get_feed_description()` since 0.8) 2718 * @return string|null 2719 */ 2720 public function get_description() 2721 { 2722 if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'subtitle')) 2723 { 2724 return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 2725 } 2726 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'tagline')) 2727 { 2728 return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 2729 } 2730 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description')) 2731 { 2732 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 2733 } 2734 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description')) 2735 { 2736 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 2737 } 2738 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description')) 2739 { 2740 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); 2741 } 2742 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description')) 2743 { 2744 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2745 } 2746 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description')) 2747 { 2748 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2749 } 2750 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary')) 2751 { 2752 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); 2753 } 2754 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle')) 2755 { 2756 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); 2757 } 2758 2759 return null; 2760 } 2761 2762 /** 2763 * Get the copyright info for the feed 2764 * 2765 * Uses `<atom:rights>`, `<atom:copyright>` or `<dc:rights>` 2766 * 2767 * @since 1.0 (previously called `get_feed_copyright()` since 0.8) 2768 * @return string|null 2769 */ 2770 public function get_copyright() 2771 { 2772 if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights')) 2773 { 2774 return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 2775 } 2776 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'copyright')) 2777 { 2778 return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 2779 } 2780 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'copyright')) 2781 { 2782 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2783 } 2784 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights')) 2785 { 2786 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2787 } 2788 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights')) 2789 { 2790 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2791 } 2792 2793 return null; 2794 } 2795 2796 /** 2797 * Get the language for the feed 2798 * 2799 * Uses `<language>`, `<dc:language>`, or @xml_lang 2800 * 2801 * @since 1.0 (previously called `get_feed_language()` since 0.8) 2802 * @return string|null 2803 */ 2804 public function get_language() 2805 { 2806 if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'language')) 2807 { 2808 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2809 } 2810 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'language')) 2811 { 2812 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2813 } 2814 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'language')) 2815 { 2816 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2817 } 2818 elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang'])) 2819 { 2820 return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); 2821 } 2822 elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang'])) 2823 { 2824 return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); 2825 } 2826 elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang'])) 2827 { 2828 return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); 2829 } 2830 elseif (isset($this->data['headers']['content-language'])) 2831 { 2832 return $this->sanitize($this->data['headers']['content-language'], SIMPLEPIE_CONSTRUCT_TEXT); 2833 } 2834 2835 return null; 2836 } 2837 2838 /** 2839 * Get the latitude coordinates for the item 2840 * 2841 * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications 2842 * 2843 * Uses `<geo:lat>` or `<georss:point>` 2844 * 2845 * @since 1.0 2846 * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo 2847 * @link http://www.georss.org/ GeoRSS 2848 * @return string|null 2849 */ 2850 public function get_latitude() 2851 { 2852 2853 if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat')) 2854 { 2855 return (float) $return[0]['data']; 2856 } 2857 elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) 2858 { 2859 return (float) $match[1]; 2860 } 2861 2862 return null; 2863 } 2864 2865 /** 2866 * Get the longitude coordinates for the feed 2867 * 2868 * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications 2869 * 2870 * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>` 2871 * 2872 * @since 1.0 2873 * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo 2874 * @link http://www.georss.org/ GeoRSS 2875 * @return string|null 2876 */ 2877 public function get_longitude() 2878 { 2879 if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long')) 2880 { 2881 return (float) $return[0]['data']; 2882 } 2883 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon')) 2884 { 2885 return (float) $return[0]['data']; 2886 } 2887 elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) 2888 { 2889 return (float) $match[2]; 2890 } 2891 2892 return null; 2893 } 2894 2895 /** 2896 * Get the feed logo's title 2897 * 2898 * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" title. 2899 * 2900 * Uses `<image><title>` or `<image><dc:title>` 2901 * 2902 * @return string|null 2903 */ 2904 public function get_image_title() 2905 { 2906 if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title')) 2907 { 2908 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2909 } 2910 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title')) 2911 { 2912 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2913 } 2914 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title')) 2915 { 2916 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2917 } 2918 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title')) 2919 { 2920 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2921 } 2922 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title')) 2923 { 2924 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 2925 } 2926 2927 return null; 2928 } 2929 2930 /** 2931 * Get the feed logo's URL 2932 * 2933 * RSS 0.9.0, 2.0, Atom 1.0, and feeds with iTunes RSS tags are allowed to 2934 * have a "feed logo" URL. This points directly to the image itself. 2935 * 2936 * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`, 2937 * `<image><title>` or `<image><dc:title>` 2938 * 2939 * @return string|null 2940 */ 2941 public function get_image_url() 2942 { 2943 if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'image')) 2944 { 2945 return $this->sanitize($return[0]['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI); 2946 } 2947 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'logo')) 2948 { 2949 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2950 } 2951 elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'icon')) 2952 { 2953 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2954 } 2955 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'url')) 2956 { 2957 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2958 } 2959 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'url')) 2960 { 2961 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2962 } 2963 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) 2964 { 2965 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2966 } 2967 2968 return null; 2969 } 2970 2971 2972 /** 2973 * Get the feed logo's link 2974 * 2975 * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" link. This 2976 * points to a human-readable page that the image should link to. 2977 * 2978 * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`, 2979 * `<image><title>` or `<image><dc:title>` 2980 * 2981 * @return string|null 2982 */ 2983 public function get_image_link() 2984 { 2985 if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link')) 2986 { 2987 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2988 } 2989 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link')) 2990 { 2991 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2992 } 2993 elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link')) 2994 { 2995 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 2996 } 2997 2998 return null; 2999 } 3000 3001 /** 3002 * Get the feed logo's link 3003 * 3004 * RSS 2.0 feeds are allowed to have a "feed logo" width. 3005 * 3006 * Uses `<image><width>` or defaults to 88.0 if no width is specified and 3007 * the feed is an RSS 2.0 feed. 3008 * 3009 * @return int|float|null 3010 */ 3011 public function get_image_width() 3012 { 3013 if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'width')) 3014 { 3015 return round($return[0]['data']); 3016 } 3017 elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) 3018 { 3019 return 88.0; 3020 } 3021 3022 return null; 3023 } 3024 3025 /** 3026 * Get the feed logo's height 3027 * 3028 * RSS 2.0 feeds are allowed to have a "feed logo" height. 3029 * 3030 * Uses `<image><height>` or defaults to 31.0 if no height is specified and 3031 * the feed is an RSS 2.0 feed. 3032 * 3033 * @return int|float|null 3034 */ 3035 public function get_image_height() 3036 { 3037 if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'height')) 3038 { 3039 return round($return[0]['data']); 3040 } 3041 elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) 3042 { 3043 return 31.0; 3044 } 3045 3046 return null; 3047 } 3048 3049 /** 3050 * Get the number of items in the feed 3051 * 3052 * This is well-suited for {@link http://php.net/for for()} loops with 3053 * {@see get_item()} 3054 * 3055 * @param int $max Maximum value to return. 0 for no limit 3056 * @return int Number of items in the feed 3057 */ 3058 public function get_item_quantity($max = 0) 3059 { 3060 $max = (int) $max; 3061 $qty = count($this->get_items()); 3062 if ($max === 0) 3063 { 3064 return $qty; 3065 } 3066 3067 return ($qty > $max) ? $max : $qty; 3068 } 3069 3070 /** 3071 * Get a single item from the feed 3072 * 3073 * This is better suited for {@link http://php.net/for for()} loops, whereas 3074 * {@see get_items()} is better suited for 3075 * {@link http://php.net/foreach foreach()} loops. 3076 * 3077 * @see get_item_quantity() 3078 * @since Beta 2 3079 * @param int $key The item that you want to return. Remember that arrays begin with 0, not 1 3080 * @return SimplePie_Item|null 3081 */ 3082 public function get_item($key = 0) 3083 { 3084 $items = $this->get_items(); 3085 if (isset($items[$key])) 3086 { 3087 return $items[$key]; 3088 } 3089 3090 return null; 3091 } 3092 3093 /** 3094 * Get all items from the feed 3095 * 3096 * This is better suited for {@link http://php.net/for for()} loops, whereas 3097 * {@see get_items()} is better suited for 3098 * {@link http://php.net/foreach foreach()} loops. 3099 * 3100 * @see get_item_quantity 3101 * @since Beta 2 3102 * @param int $start Index to start at 3103 * @param int $end Number of items to return. 0 for all items after `$start` 3104 * @return SimplePie_Item[]|null List of {@see SimplePie_Item} objects 3105 */ 3106 public function get_items($start = 0, $end = 0) 3107 { 3108 if (!isset($this->data['items'])) 3109 { 3110 if (!empty($this->multifeed_objects)) 3111 { 3112 $this->data['items'] = SimplePie::merge_items($this->multifeed_objects, $start, $end, $this->item_limit); 3113 if (empty($this->data['items'])) 3114 { 3115 return array(); 3116 } 3117 return $this->data['items']; 3118 } 3119 $this->data['items'] = array(); 3120 if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'entry')) 3121 { 3122 $keys = array_keys($items); 3123 foreach ($keys as $key) 3124 { 3125 $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 3126 } 3127 } 3128 if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'entry')) 3129 { 3130 $keys = array_keys($items); 3131 foreach ($keys as $key) 3132 { 3133 $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 3134 } 3135 } 3136 if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'item')) 3137 { 3138 $keys = array_keys($items); 3139 foreach ($keys as $key) 3140 { 3141 $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 3142 } 3143 } 3144 if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'item')) 3145 { 3146 $keys = array_keys($items); 3147 foreach ($keys as $key) 3148 { 3149 $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 3150 } 3151 } 3152 if ($items = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'item')) 3153 { 3154 $keys = array_keys($items); 3155 foreach ($keys as $key) 3156 { 3157 $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 3158 } 3159 } 3160 } 3161 3162 if (empty($this->data['items'])) 3163 { 3164 return array(); 3165 } 3166 3167 if ($this->order_by_date) 3168 { 3169 if (!isset($this->data['ordered_items'])) 3170 { 3171 $this->data['ordered_items'] = $this->data['items']; 3172 usort($this->data['ordered_items'], array(get_class($this), 'sort_items')); 3173 } 3174 $items = $this->data['ordered_items']; 3175 } 3176 else 3177 { 3178 $items = $this->data['items']; 3179 } 3180 // Slice the data as desired 3181 if ($end === 0) 3182 { 3183 return array_slice($items, $start); 3184 } 3185 3186 return array_slice($items, $start, $end); 3187 } 3188 3189 /** 3190 * Set the favicon handler 3191 * 3192 * @deprecated Use your own favicon handling instead 3193 */ 3194 public function set_favicon_handler($page = false, $qs = 'i') 3195 { 3196 $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 3197 trigger_error('Favicon handling has been removed, please use your own handling', $level); 3198 return false; 3199 } 3200 3201 /** 3202 * Get the favicon for the current feed 3203 * 3204 * @deprecated Use your own favicon handling instead 3205 */ 3206 public function get_favicon() 3207 { 3208 $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 3209 trigger_error('Favicon handling has been removed, please use your own handling', $level); 3210 3211 if (($url = $this->get_link()) !== null) 3212 { 3213 return 'https://www.google.com/s2/favicons?domain=' . urlencode($url); 3214 } 3215 3216 return false; 3217 } 3218 3219 /** 3220 * Magic method handler 3221 * 3222 * @param string $method Method name 3223 * @param array $args Arguments to the method 3224 * @return mixed 3225 */ 3226 public function __call($method, $args) 3227 { 3228 if (strpos($method, 'subscribe_') === 0) 3229 { 3230 $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 3231 trigger_error('subscribe_*() has been deprecated, implement the callback yourself', $level); 3232 return ''; 3233 } 3234 if ($method === 'enable_xml_dump') 3235 { 3236 $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 3237 trigger_error('enable_xml_dump() has been deprecated, use get_raw_data() instead', $level); 3238 return false; 3239 } 3240 3241 $class = get_class($this); 3242 $trace = debug_backtrace(); // phpcs:ignore PHPCompatibility.FunctionUse.ArgumentFunctionsReportCurrentValue.NeedsInspection 3243 $file = $trace[0]['file']; 3244 $line = $trace[0]['line']; 3245 trigger_error("Call to undefined method $class::$method() in $file on line $line", E_USER_ERROR); 3246 } 3247 3248 /** 3249 * Sorting callback for items 3250 * 3251 * @access private 3252 * @param SimplePie $a 3253 * @param SimplePie $b 3254 * @return boolean 3255 */ 3256 public static function sort_items($a, $b) 3257 { 3258 $a_date = $a->get_date('U'); 3259 $b_date = $b->get_date('U'); 3260 if ($a_date && $b_date) { 3261 return $a_date > $b_date ? -1 : 1; 3262 } 3263 // Sort items without dates to the top. 3264 if ($a_date) { 3265 return 1; 3266 } 3267 if ($b_date) { 3268 return -1; 3269 } 3270 return 0; 3271 } 3272 3273 /** 3274 * Merge items from several feeds into one 3275 * 3276 * If you're merging multiple feeds together, they need to all have dates 3277 * for the items or else SimplePie will refuse to sort them. 3278 * 3279 * @link http://simplepie.org/wiki/tutorial/sort_multiple_feeds_by_time_and_date#if_feeds_require_separate_per-feed_settings 3280 * @param array $urls List of SimplePie feed objects to merge 3281 * @param int $start Starting item 3282 * @param int $end Number of items to return 3283 * @param int $limit Maximum number of items per feed 3284 * @return array 3285 */ 3286 public static function merge_items($urls, $start = 0, $end = 0, $limit = 0) 3287 { 3288 if (is_array($urls) && sizeof($urls) > 0) 3289 { 3290 $items = array(); 3291 foreach ($urls as $arg) 3292 { 3293 if ($arg instanceof SimplePie) 3294 { 3295 $items = array_merge($items, $arg->get_items(0, $limit)); 3296 } 3297 else 3298 { 3299 trigger_error('Arguments must be SimplePie objects', E_USER_WARNING); 3300 } 3301 } 3302 3303 usort($items, array(get_class($urls[0]), 'sort_items')); 3304 3305 if ($end === 0) 3306 { 3307 return array_slice($items, $start); 3308 } 3309 3310 return array_slice($items, $start, $end); 3311 } 3312 3313 trigger_error('Cannot merge zero SimplePie objects', E_USER_WARNING); 3314 return array(); 3315 } 3316 3317 /** 3318 * Store PubSubHubbub links as headers 3319 * 3320 * There is no way to find PuSH links in the body of a microformats feed, 3321 * so they are added to the headers when found, to be used later by get_links. 3322 * @param SimplePie_File $file 3323 * @param string $hub 3324 * @param string $self 3325 */ 3326 private function store_links(&$file, $hub, $self) { 3327 if (isset($file->headers['link']['hub']) || 3328 (isset($file->headers['link']) && 3329 preg_match('/rel=hub/', $file->headers['link']))) 3330 { 3331 return; 3332 } 3333 3334 if ($hub) 3335 { 3336 if (isset($file->headers['link'])) 3337 { 3338 if ($file->headers['link'] !== '') 3339 { 3340 $file->headers['link'] = ', '; 3341 } 3342 } 3343 else 3344 { 3345 $file->headers['link'] = ''; 3346 } 3347 $file->headers['link'] .= '<'.$hub.'>; rel=hub'; 3348 if ($self) 3349 { 3350 $file->headers['link'] .= ', <'.$self.'>; rel=self'; 3351 } 3352 } 3353 } 3354 } 3355 endif;
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated : Fri Apr 26 08:20:02 2024 | Cross-referenced by PHPXref |