root/tags/1_0-rc1/wp-includes/rss.php

<?php

/* Much of the code in this file was taken from MagpieRSS
 * by Kellan Elliott-McCrea <kellan@protest.net> which is
 * released under the GPL license.
 *
 * The lastest version of MagpieRSS can be obtained from:
 * http://magpierss.sourceforge.net
 */

function fetch_rss($url) {
    $url = apply_filters('fetch_rss_url', $url);

    $feeder = new WP_Feeder();

    $feed = $feeder->get($url);

    $magpie = $feed->to_magpie();

    return $magpie;
}

class WP_Feeder {
    var $url, $http_client, $last_fetch, $wp_object_cache, $cache;
    var $redirects = 0;
    var $max_redirects = 3;
    var $cache_redirects = true;

    function WP_Feeder () {
        global $wp_object_cache;
        
        if ( $wp_object_cache->cache_enabled ) {
            $this->wp_object_cache = true;
        } else {
            $this->wp_object_cache = false;
            $this->cache = new RSSCache();
        }
    }

    function get ($url) {
        $cached = false;

        $feed = $this->cache_get($url);

        if ( is_object($feed) ) {
            $cached = true;
        } else {
            unset($feed);

            $this->fetch($url);

            $feed = new WP_Feed($this->http_client);
        }

        // Handle redirects
        if ( $feed->status >= 300 && $feed->status < 400 && $this->redirects < $this->max_redirects ) {
            ++$this->redirects;

            if ( $this->cache_redirects && !$cached )
                $this->cache_set($url, $feed);

            return $this->get($feed->redirect_location);
        }

        if ( !$cached )
            $this->cache_set($url, $feed);

        return $feed;
    }

    function fetch ($url) {
        $this->last_fetch = $url;
        $parts = parse_url($url);
        $url = ($parts['path'] ? $parts['path'] : '/') . ($parts['query'] ? '?'.$parts['query'] : '');
        $this->http_client = new HttpClient('', 80);
        $this->http_client->handle_redirects = false;
        $this->http_client->host = $parts['host'];
        $this->http_client->port = $parts['port'] ? $parts['port'] : 80;
        $this->http_client->user_agent = 'WordPress ' . $GLOBALS['wp_version'] . ' Feed Client';
        $this->http_client->get($url);
    }
    
    function cache_get ($url) {
        if ( $this->wp_object_cache )
            return unserialize(wp_cache_get($url, 'rss'));

        return $this->cache->get($url);
    }
    
    function cache_set ($url, $object) {
        if ( $this->wp_object_cache )
            return wp_cache_set($url, serialize($object), 'rss', 3600);
        
        return $this->cache->set($url, $object);
    }
}

class RSSCache {
    var $BASE_CACHE = 'wp-content/cache';    // where the cache files are stored
    var $MAX_AGE    = 43200;          // when are files stale, default twelve hours
    var $ERROR         = '';            // accumulate error messages

    function RSSCache ($base='', $age='') {
        if ( $base ) {
            $this->BASE_CACHE = $base;
        }
        if ( $age ) {
            $this->MAX_AGE = $age;
        }

    }

    function set ($url, $rss) {
        global $wpdb;
        $cache_option = 'rss_' . $this->file_name( $url );
        $cache_timestamp = 'rss_' . $this->file_name( $url ) . '_ts';

        if ( !$wpdb->get_var("SELECT option_name FROM $wpdb->options WHERE option_name = '$cache_option'") )
            add_option($cache_option, '', '', 'no');
        if ( !$wpdb->get_var("SELECT option_name FROM $wpdb->options WHERE option_name = '$cache_timestamp'") )
            add_option($cache_timestamp, '', '', 'no');

        update_option($cache_option, $rss);
        update_option($cache_timestamp, time() );

        return $cache_option;
    }

    function get ($url) {
        $this->ERROR = "";
        $cache_option = 'rss_' . $this->file_name( $url );

        if ( ! get_option( $cache_option ) ) {
            $this->debug( 
                "Cache doesn't contain: $url (cache option: $cache_option)"
            );
            return 0;
        }

        $rss = get_option( $cache_option );

        return $rss;
    }

    function check_cache ( $url ) {
        $this->ERROR = "";
        $cache_option = $this->file_name( $url );
        $cache_timestamp = 'rss_' . $this->file_name( $url ) . '_ts';

        if ( $mtime = get_option($cache_timestamp) ) {
            // find how long ago the file was added to the cache
            // and whether that is longer then MAX_AGE
            $age = time() - $mtime;
            if ( $this->MAX_AGE > $age ) {
                // object exists and is current
                return 'HIT';
            }
            else {
                // object exists but is old
                return 'STALE';
            }
        }
        else {
            // object does not exist
            return 'MISS';
        }
    }

    function serialize ( $rss ) {
        return serialize( $rss );
    }

    function unserialize ( $data ) {
        return unserialize( $data );
    }

    function file_name ($url) {
        return md5( $url );
    }

    function error ($errormsg, $lvl=E_USER_WARNING) {
        // append PHP's error message if track_errors enabled
        if ( isset($php_errormsg) ) { 
            $errormsg .= " ($php_errormsg)";
        }
        $this->ERROR = $errormsg;
        if ( MAGPIE_DEBUG ) {
            trigger_error( $errormsg, $lvl);
        }
        else {
            error_log( $errormsg, 0);
        }
    }
            function debug ($debugmsg, $lvl=E_USER_NOTICE) {
        if ( MAGPIE_DEBUG ) {
            $this->error("MagpieRSS [debug] $debugmsg", $lvl);
        }
    }
}

class WP_Feed {
    var $status;
    var $raw_xml;
    var $last_updated;
    var $tree;
    var $items;
    var $children;

    var $parser;
    var $feed_type;
    var $feed_version;
    var $stack = array();

    function WP_Feed ($source)
    {
        # if PHP xml isn't compiled in, die
        #
        if (!function_exists('xml_parser_create')) {
            $this->error( "Failed to load PHP's XML Extension. " .
            "http://www.php.net/manual/en/ref.xml.php",
            E_USER_ERROR );
        }

        // Handle overloaded arg (string or HttpClient object)
        if ( is_object($source) ) {
            if ( $source->status >= 200 && $source->status < 300) {
                $this->etag = $source->headers['etag'];
                $this->last_modified = $source->headers['last-modified'];
                $source = $source->content;
            } else {
                $this->scour();
                $this->status = $source->status;
                $this->redirect_location = $source->headers->location;
                $this->bathe();
                return;
            }
        }

        list($parser, $source) = $this->create_parser($source, 'UTF-8', null, true);

        if (!is_resource($parser)) {
            $this->error( "Failed to create an instance of PHP's XML parser. " .
            "http://www.php.net/manual/en/ref.xml.php",
            E_USER_ERROR );
        }

        $this->parser = $parser;

        # pass in parser, and a reference to this object
        # setup handlers
        #
        xml_set_object($this->parser, $this);
        xml_set_element_handler($this->parser, 'start_element', 'end_element');
        xml_set_character_data_handler( $this->parser, 'cdata');

        $status = xml_parse( $this->parser, $source );

        if (! $status ) {
            $errorcode = xml_get_error_code( $this->parser );
            if ( $errorcode != XML_ERROR_NONE ) {
                $xml_error = xml_error_string( $errorcode );
                $error_line = xml_get_current_line_number($this->parser);
                $error_col = xml_get_current_column_number($this->parser);
                $errormsg = "$xml_error at line $error_line, column $error_col";

                $this->error( $errormsg );
            }
        }

        // SUPER SLOPPY FEED DISCOVERY!! TO-DO: AXE THIS CRAP!!
        if ( !is_object($this->feed) || !method_exists($this->feed, 'to_xml') ) {
            if ( preg_match_all('/<link [^>]*href=([^ >]+)[^>]+>/i', $source, $matches) ) {
                $types = array('rss', 'atom');
                foreach ( $types as $type )
                    foreach ( $matches[0] as $key => $link )
                        if ( preg_match('/rel=.alternate./', $link) && preg_match("/type=[^ >]*{$type}[^ >]*/", $link) )
                            break 2;
                $this->scour();
                $this->redirect_location = 'http://xml.wordpress.com/get/' . trim($matches[1][$key], '\'"');
                $this->status = 301;
                return;
            } else {
                $this->scour();
                $this->status = 404;
                return;
            }
        } else {
            $this->status = 200;
        }

        xml_parser_free( $this->parser );
        unset($this->parser);

        $this->bathe();
    }

    function to_xml() {
        if ( is_object($this->feed) && method_exists($this->feed, 'to_xml') )
            return $this->feed->to_xml();

        return false;
    }

    // Called internally by xml_parse(). We create an object and call its start_element method.
    function start_element($p, $element, &$attrs) {
        $el = $element;// = strtolower($element);
        // $attrs = array_change_key_case($attrs, CASE_LOWER);

        // If there is an extended class for this element, use it.
        $class = 'element';

        $maybe_class = $test_class = strtolower(str_replace(':', '_', $el));
        if ( class_exists($maybe_class) ) {
            for ($classes[] = $test_class; $test_class = get_parent_class ($test_class); $classes[] = $test_class);
            if ( in_array($class, $classes) )
                $class = $maybe_class;
        }

        // Instantiate an object for this element.
        $object = new $class();

        // Tell the element to start itself.
        $object->start_element($p, $element, $attrs, $this);
    }

    function cdata ($p, $data) {
        $this->stack[0]->cdata($p, $data, $this);
    }

    function end_element ($p, $el) {
        $this->stack[0]->end_element($p, $el, $this);
    }

    function create_parser($source, $out_enc, $in_enc, $detect) {
        if ( substr(phpversion(),0,1) == 5) {
            $parser = $this->php5_create_parser($in_enc, $detect);
        }
        else {
            list($parser, $source) = $this->php4_create_parser($source, $in_enc, $detect);
        }
        if ($out_enc) {
            $this->encoding = $out_enc;
            xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $out_enc);
            xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
        }

        return array($parser, $source);
    }

    function php5_create_parser($in_enc, $detect) {
        // by default php5 does a fine job of detecting input encodings
        if(!$detect && $in_enc) {
            return xml_parser_create($in_enc);
        }
        else {
            return xml_parser_create('');
        }
    }

    /**
    * Instaniate an XML parser under PHP4
    *
    * Unfortunately PHP4's support for character encodings
    * and especially XML and character encodings sucks.  As
    * long as the documents you parse only contain characters
    * from the ISO-8859-1 character set (a superset of ASCII,
    * and a subset of UTF-8) you're fine.  However once you
    * step out of that comfy little world things get mad, bad,
    * and dangerous to know.
    *
    * The following code is based on SJM's work with FoF
    * @see http://minutillo.com/steve/weblog/2004/6/17/php-xml-and-character-encodings-a-tale-of-sadness-rage-and-data-loss
    *
    */
    function php4_create_parser($source, $in_enc, $detect) {
        if ( !$detect ) {
            return array(xml_parser_create($in_enc), $source);
        }

        if (!$in_enc) {
            if (preg_match('/<?xml.*encoding=[\'"](.*?)[\'"].*?>/m', $source, $m)) {
                $in_enc = strtoupper($m[1]);
                $this->source_encoding = $in_enc;
            }
            else {
                $in_enc = 'UTF-8';
            }
        }

        if ($this->known_encoding($in_enc)) {
            return array(xml_parser_create($in_enc), $source);
        }

        // the dectected encoding is not one of the simple encodings PHP knows

        // attempt to use the iconv extension to
        // cast the XML to a known encoding
        // @see http://php.net/iconv

        if (function_exists('iconv'))  {
            $encoded_source = iconv($in_enc,'UTF-8', $source);
            if ($encoded_source) {
                return array(xml_parser_create('UTF-8'), $encoded_source);
            }
        }

        // iconv didn't work, try mb_convert_encoding
        // @see http://php.net/mbstring
        if(function_exists('mb_convert_encoding')) {
            $encoded_source = mb_convert_encoding($source, 'UTF-8', $in_enc );
            if ($encoded_source) {
                return array(xml_parser_create('UTF-8'), $encoded_source);
            }
        }

        // else
        $this->error("Feed is in an unsupported character encoding. ($in_enc) " .
        "You may see strange artifacts, and mangled characters.",
        E_USER_NOTICE);

        return array(xml_parser_create(), $source);
    }

    function known_encoding($enc) {
        $enc = strtoupper($enc);
        if ( in_array($enc, array('UTF-8', 'US-ASCII', 'ISO-8859-1')) ) {
            return $enc;
        }
        else {
            return false;
        }
    }

    function error ($errormsg, $lvl=E_USER_WARNING) {
        // append PHP's error message if track_errors enabled
        if ( isset($php_errormsg) ) {
            $errormsg .= " ($php_errormsg)";
        }
        if ( MAGPIE_DEBUG ) {
        //    trigger_error( $errormsg, $lvl);
        }
        else {
            error_log( $errormsg, 0);
        }

        $notices = E_USER_NOTICE|E_NOTICE;
        if ( $lvl&$notices ) {
            $this->WARNING = $errormsg;
        } else {
            $this->ERROR = $errormsg;
        }
    }

    // Remove empty and |^_.*| object vars
    function bathe() {
        foreach ( get_object_vars($this) as $key => $data )
            if ( empty($this->$key) || substr($key, 0, 1) == '_' )
                unset($this->$key);
    }

    // Remove ALL object vars
    function scour() {
        foreach ( get_object_vars($this) as $key => $data )
            unset($this->$key);
    }
    
    function to_magpie() {
        $magpie = new stdClass();

        foreach ( $this as $var => $value ) {
            if ( $var == 'feed' ) {
                continue;
            } else {
                $magpie->$var = $this->$var;
            }
        }

        $magpie->items = array();

        if ( is_object($this->feed) && method_exists($this->feed, 'to_magpie') ) {
            $feed = $this->feed->to_magpie();

            if ( is_array($feed) ) {
                foreach ( $this->feed->to_magpie() as $var => $val ) {
                    if ( $var == 'items' )
                        $magpie->items = $val;
                    else 
                        $magpie->channel["$var"] = $val;
                }
            }
        }

        return $magpie;
    }
}


class element {
    function element() {
    }

    function start_element($p, $el, $attr, &$mag) {
        $this->name = $el;
        $this->attributes = $attr;

        array_unshift($mag->stack, $this);
    }
    function cdata($p, $data