| <?php | |
| /** | |
| * This is the HTML pseudo-parser for the Yadis library. | |
| * | |
| * PHP versions 4 and 5 | |
| * | |
| * LICENSE: See the COPYING file included in this distribution. | |
| * | |
| * @package OpenID | |
| * @author JanRain, Inc. <openid@janrain.com> | |
| * @copyright 2005-2008 Janrain, Inc. | |
| * @license http://www.apache.org/licenses/LICENSE-2.0 Apache | |
| */ | |
| /** | |
| * This class is responsible for scanning an HTML string to find META | |
| * tags and their attributes. This is used by the Yadis discovery | |
| * process. This class must be instantiated to be used. | |
| * | |
| * @package OpenID | |
| */ | |
| class Auth_Yadis_ParseHTML { | |
| /** | |
| * @access private | |
| */ | |
| var $_re_flags = "si"; | |
| /** | |
| * @access private | |
| */ | |
| var $_removed_re = | |
| "<!--.*?-->|<!\[CDATA\[.*?\]\]>|<script\b(?!:)[^>]*>.*?<\/script>"; | |
| /** | |
| * @access private | |
| */ | |
| var $_tag_expr = "<%s%s(?:\s.*?)?%s>"; | |
| /** | |
| * @access private | |
| */ | |
| var $_attr_find = '\b([-\w]+)=(".*?"|\'.*?\'|.+?)[\/\s>]'; | |
| function Auth_Yadis_ParseHTML() | |
| { | |
| $this->_attr_find = sprintf("/%s/%s", | |
| $this->_attr_find, | |
| $this->_re_flags); | |
| $this->_removed_re = sprintf("/%s/%s", | |
| $this->_removed_re, | |
| $this->_re_flags); | |
| $this->_entity_replacements = array( | |
| 'amp' => '&', | |
| 'lt' => '<', | |
| 'gt' => '>', | |
| 'quot' => '"' | |
| ); | |
| $this->_ent_replace = | |
| sprintf("&(%s);", implode("|", | |
| $this->_entity_replacements)); | |
| } | |
| /** | |
| * Replace HTML entities (amp, lt, gt, and quot) as well as | |
| * numeric entities (e.g. #x9f;) with their actual values and | |
| * return the new string. | |
| * | |
| * @access private | |
| * @param string $str The string in which to look for entities | |
| * @return string $new_str The new string entities decoded | |
| */ | |
| function replaceEntities($str) | |
| { | |
| foreach ($this->_entity_replacements as $old => $new) { | |
| $str = preg_replace(sprintf("/&%s;/", $old), $new, $str); | |
| } | |
| // Replace numeric entities because html_entity_decode doesn't | |
| // do it for us. | |
| $str = preg_replace('~&#x([0-9a-f]+);~ei', 'chr(hexdec("\\1"))', $str); | |
| $str = preg_replace('~&#([0-9]+);~e', 'chr(\\1)', $str); | |
| return $str; | |
| } | |
| /** | |
| * Strip single and double quotes off of a string, if they are | |
| * present. | |
| * | |
| * @access private | |
| * @param string $str The original string | |
| * @return string $new_str The new string with leading and | |
| * trailing quotes removed | |
| */ | |
| function removeQuotes($str) | |
| { | |
| $matches = array(); | |
| $double = '/^"(.*)"$/'; | |
| $single = "/^\'(.*)\'$/"; | |
| if (preg_match($double, $str, $matches)) { | |
| return $matches[1]; | |
| } else if (preg_match($single, $str, $matches)) { | |
| return $matches[1]; | |
| } else { | |
| return $str; | |
| } | |
| } | |
| /** | |
| * Create a regular expression that will match an opening | |
| * or closing tag from a set of names. | |
| * | |
| * @access private | |
| * @param mixed $tag_names Tag names to match | |
| * @param mixed $close false/0 = no, true/1 = yes, other = maybe | |
| * @param mixed $self_close false/0 = no, true/1 = yes, other = maybe | |
| * @return string $regex A regular expression string to be used | |
| * in, say, preg_match. | |
| */ | |
| function tagPattern($tag_names, $close, $self_close) | |
| { | |
| if (is_array($tag_names)) { | |
| $tag_names = '(?:'.implode('|',$tag_names).')'; | |
| } | |
| if ($close) { | |
| $close = '\/' . (($close == 1)? '' : '?'); | |
| } else { | |
| $close = ''; | |
| } | |
| if ($self_close) { | |
| $self_close = '(?:\/\s*)' . (($self_close == 1)? '' : '?'); | |
| } else { | |
| $self_close = ''; | |
| } | |
| $expr = sprintf($this->_tag_expr, $close, $tag_names, $self_close); | |
| return sprintf("/%s/%s", $expr, $this->_re_flags); | |
| } | |
| /** | |
| * Given an HTML document string, this finds all the META tags in | |
| * the document, provided they are found in the | |
| * <HTML><HEAD>...</HEAD> section of the document. The <HTML> tag | |
| * may be missing. | |
| * | |
| * @access private | |
| * @param string $html_string An HTMl document string | |
| * @return array $tag_list Array of tags; each tag is an array of | |
| * attribute -> value. | |
| */ | |
| function getMetaTags($html_string) | |
| { | |
| $html_string = preg_replace($this->_removed_re, | |
| "", | |
| $html_string); | |
| $key_tags = array($this->tagPattern('html', false, false), | |
| $this->tagPattern('head', false, false), | |
| $this->tagPattern('head', true, false), | |
| $this->tagPattern('html', true, false), | |
| $this->tagPattern(array( | |
| 'body', 'frameset', 'frame', 'p', 'div', | |
| 'table','span','a'), 'maybe', 'maybe')); | |
| $key_tags_pos = array(); | |
| foreach ($key_tags as $pat) { | |
| $matches = array(); | |
| preg_match($pat, $html_string, $matches, PREG_OFFSET_CAPTURE); | |
| if($matches) { | |
| $key_tags_pos[] = $matches[0][1]; | |
| } else { | |
| $key_tags_pos[] = null; | |
| } | |
| } | |
| // no opening head tag | |
| if (is_null($key_tags_pos[1])) { | |
| return array(); | |
| } | |
| // the effective </head> is the min of the following | |
| if (is_null($key_tags_pos[2])) { | |
| $key_tags_pos[2] = strlen($html_string); | |
| } | |
| foreach (array($key_tags_pos[3], $key_tags_pos[4]) as $pos) { | |
| if (!is_null($pos) && $pos < $key_tags_pos[2]) { | |
| $key_tags_pos[2] = $pos; | |
| } | |
| } | |
| // closing head tag comes before opening head tag | |
| if ($key_tags_pos[1] > $key_tags_pos[2]) { | |
| return array(); | |
| } | |
| // if there is an opening html tag, make sure the opening head tag | |
| // comes after it | |
| if (!is_null($key_tags_pos[0]) && $key_tags_pos[1] < $key_tags_pos[0]) { | |
| return array(); | |
| } | |
| $html_string = substr($html_string, $key_tags_pos[1], | |
| ($key_tags_pos[2]-$key_tags_pos[1])); | |
| $link_data = array(); | |
| $link_matches = array(); | |
| if (!preg_match_all($this->tagPattern('meta', false, 'maybe'), | |
| $html_string, $link_matches)) { | |
| return array(); | |
| } | |
| foreach ($link_matches[0] as $link) { | |
| $attr_matches = array(); | |
| preg_match_all($this->_attr_find, $link, $attr_matches); | |
| $link_attrs = array(); | |
| foreach ($attr_matches[0] as $index => $full_match) { | |
| $name = $attr_matches[1][$index]; | |
| $value = $this->replaceEntities( | |
| $this->removeQuotes($attr_matches[2][$index])); | |
| $link_attrs[strtolower($name)] = $value; | |
| } | |
| $link_data[] = $link_attrs; | |
| } | |
| return $link_data; | |
| } | |
| /** | |
| * Looks for a META tag with an "http-equiv" attribute whose value | |
| * is one of ("x-xrds-location", "x-yadis-location"), ignoring | |
| * case. If such a META tag is found, its "content" attribute | |
| * value is returned. | |
| * | |
| * @param string $html_string An HTML document in string format | |
| * @return mixed $content The "content" attribute value of the | |
| * META tag, if found, or null if no such tag was found. | |
| */ | |
| function getHTTPEquiv($html_string) | |
| { | |
| $meta_tags = $this->getMetaTags($html_string); | |
| if ($meta_tags) { | |
| foreach ($meta_tags as $tag) { | |
| if (array_key_exists('http-equiv', $tag) && | |
| (in_array(strtolower($tag['http-equiv']), | |
| array('x-xrds-location', 'x-yadis-location'))) && | |
| array_key_exists('content', $tag)) { | |
| return $tag['content']; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| } | |