Ticket #33134: 33134_shortcodes.diff

src/wp-includes/shortcodes.php

@@ -187 +187 @@
  */
 function do_shortcode( $content, $ignore_html = false ) {
         global $shortcode_tags;
+        global $wp_placeholder_shortcode_matches;
 
         if ( false === strpos( $content, '[' ) ) {
                 return $content;
@@ -195 +196 @@
         if (empty($shortcode_tags) || !is_array($shortcode_tags))
                 return $content;
 
-        $tagnames = array_keys($shortcode_tags);
-        $tagregexp = join( '|', array_map('preg_quote', $tagnames) );
-        $pattern = "/\\[($tagregexp)/s";
+        if ( ! empty( $wp_placeholder_shortcode_matches[current_filter()] ) ) {
+                if ( $pattern = get_shortcode_placeholder_regex( get_shortcode_tagnames( $content ) ) ) {
+                        $content = preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $content );
+                }
+        } else {
+                $tagnames = array_keys($shortcode_tags);
+                $tagregexp = join( '|', array_map('preg_quote', $tagnames) );
+                $pattern = "/\\[($tagregexp)/s";
 
-        if ( 1 !== preg_match( $pattern, $content ) ) {
-                // Avoids parsing HTML when there are no shortcodes or embeds anyway.
-                return $content;
-        }
+                if ( 1 !== preg_match( $pattern, $content ) ) {
+                        // Avoids parsing HTML when there are no shortcodes or embeds anyway.
+                        return $content;
+                }
 
-        $content = do_shortcodes_in_html_tags( $content, $ignore_html );
+                $content = do_shortcodes_in_html_tags( $content, $ignore_html );
 
-        $pattern = get_shortcode_regex();
-        $content = preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $content );
+                $pattern = get_shortcode_regex();
+                $content = preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $content );
 
-        // Always restore square braces so we don't break things like <!--[if IE ]>
-        $content = unescape_invalid_shortcodes( $content );
+                // Always restore square braces so we don't break things like <!--[if IE ]>
+                $content = unescape_invalid_shortcodes( $content );
+        }
 
         return $content;
 }
@@ -236 +243 @@
  *
  * @return string The shortcode search regular expression
  */
-function get_shortcode_regex() {
+function get_shortcode_regex( $tagnames = null, $tagregexp_only = false ) {
         global $shortcode_tags;
-        $tagnames = array_keys($shortcode_tags);
+
+        if ( $tagnames === null ) {
+                $tagnames = array_keys( $shortcode_tags );
+        }
+        if ( ! $tagnames ) {
+                return '';
+        }
+
         $tagregexp = join( '|', array_map('preg_quote', $tagnames) );
 
+        if ( $tagregexp_only ) {
+                return $tagregexp;
+        }
+
         // WARNING! Do not change this regex without changing do_shortcode_tag() and strip_shortcode_tag()
         // Also, see shortcode_unautop() and shortcode.js.
         return
@@ -275 +293 @@
 }
 
 /**
+ * Shortcode placeholder regex.
+ * Simpler, compatible with above for normal "[shortcode n]" placeholders,
+ * plus matches shortcode in html placeholders "<tag[shortcode n!]>" for KSES processing.
+ */
+function get_shortcode_placeholder_regex( $tagnames = null, $exclude_html_tag_regex = false ) {
+        global $shortcode_tags;
+        
+        if ( $tagnames === null ) {
+                $tagnames = array_keys( $shortcode_tags );
+        }
+        if ( ! $tagnames ) {
+                return '';
+        }
+
+        $tagregexp = get_shortcode_regex( $tagnames, true /*$tagregexp_only*/ );
+
+        $html_tag_regex = $exclude_html_tag_regex ? '' : '<[A-Za-z][A-Za-z0-9]*\[(?:' . $tagregexp . ') \d+!]>' . '|';
+
+        return
+                $html_tag_regex
+                . '\['                              // Opening bracket
+                . '()'                              // 1: (null for compatibility with get_shortcode_regex())
+                . "($tagregexp)"                    // 2: Shortcode name
+                . ' '                               // Followed by space 
+                . '(\d+)'                           // 3: number
+                . '()'                              // 4: (null for compatibility with get_shortcode_regex())
+                . ']'                               // Then closing bracket
+                .     '(?:'
+                .         '('                       // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags
+                .             '[^[]*+'              // Not an opening bracket
+                .             '(?:'
+                .                 '\[(?!\/\\2])'    // An opening bracket not followed by the closing shortcode tag
+                .                 '[^[]*+'          // Not an opening bracket
+                .             ')*+'
+                .         ')'
+                .         '\[\/\\2]'                // Closing shortcode tag
+                .     ')?'
+                . '()';                             // 6: (null for compatibility with get_shortcode_regex())
+}
+
+/**
+ * Return registered shortcode tagnames, reduced to those in $text if given.
+ */
+function get_shortcode_tagnames( $text = null ) {
+        global $shortcode_tags;
+
+        $tagnames = array_keys( $shortcode_tags );
+        if ( $text !== null ) {
+                preg_match_all( '/\[\K[^][\s\/]++/', $text, $matches );
+                // Reduce to registered shortcodes.
+                $tagnames = array_values( array_intersect( array_unique( $matches[0] ), $tagnames ) );
+        }
+        return $tagnames;
+}
+
+/**
  * Regular Expression callable for do_shortcode() for calling shortcode hook.
  * @see get_shortcode_regex for details of the match array contents.
  *
@@ -288 +362 @@
  */
 function do_shortcode_tag( $m ) {
         global $shortcode_tags;
+        global $wp_placeholder_shortcode_matches, $wp_placeholder_shortcode_in_html_tags;
+        static $in_html_tags = false;
 
+        $current_filter = current_filter();
+
+        // Check for in html placeholder ("<tag[shortcode n!]>").
+        if ( ! $in_html_tags && '<' === $m[0][0] && isset( $wp_placeholder_shortcode_in_html_tags[$current_filter][$m[0]] ) ) {
+                $in_html_tags = true;
+                $element = $wp_placeholder_shortcode_in_html_tags[$current_filter][$m[0]];
+                $pattern = get_shortcode_placeholder_regex( get_shortcode_tagnames( $element ), true /*$exclude_html_tag_regex*/ );
+                $attributes = wp_kses_attr_parse( $element );
+                if ( false === $attributes ) {
+                        // Some plugins are doing things like [name] <[email]>.
+                        if ( 1 === preg_match( '%^<\s*\[\[?[^\[\]]+\]%', $element ) ) {
+                                $element = preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $element );
+                        }
+                } else {
+
+                        // Get element name
+                        $front = array_shift( $attributes );
+                        $back = array_pop( $attributes );
+                        $matches = array();
+                        preg_match('%[a-zA-Z0-9]+%', $front, $matches);
+                        $elname = $matches[0];
+
+                        // Look for shortcodes in each attribute separately.
+                        foreach ( $attributes as &$attr ) {
+                                $open = strpos( $attr, '[' );
+                                $close = strpos( $attr, ']' );
+                                if ( false === $open || false === $close ) {
+                                        continue; // Go to next attribute.  Square braces will be escaped at end of loop.
+                                }
+                                $double = strpos( $attr, '"' );
+                                $single = strpos( $attr, "'" );
+                                if ( ( false === $single || $open < $single ) && ( false === $double || $open < $double ) ) {
+                                        // $attr like '[shortcode]' or 'name = [shortcode]' implies unfiltered_html.
+                                        // In this specific situation we assume KSES did not run because the input
+                                        // was written by an administrator, so we should avoid changing the output
+                                        // and we do not need to run KSES here.
+                                        $attr = preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $attr );
+                                } else {
+                                        // $attr like 'name = "[shortcode]"' or "name = '[shortcode]'"
+                                        // We do not know if $content was unfiltered. Assume KSES ran before shortcodes.
+                                        $count = 0;
+                                        $new_attr = preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $attr, -1, $count );
+                                        if ( $count > 0 ) {
+                                                // Sanitize the shortcode output using KSES.
+                                                $new_attr = wp_kses_one_attr( $new_attr, $elname );
+                                                if ( '' !== trim( $new_attr ) ) {
+                                                        // The shortcode is safe to use now.
+                                                        $attr = $new_attr;
+                                                }
+                                        }
+                                }
+                        }
+                        $element = $front . implode( '', $attributes ) . $back;
+                }
+                $in_html_tags = false;
+                return $element;
+        } elseif ( $m[3] !== '' && isset( $wp_placeholder_shortcode_matches[$current_filter][$m[2] . ' '. $m[3]] ) ) { // Else if normal shortcode placeholder ("[shortcode n]").
+                $m = $wp_placeholder_shortcode_matches[$current_filter][$m[2] . ' '. $m[3]];
+        }
+
         // allow [[foo]] syntax for escaping a tag
         if ( $m[1] == '[' && $m[6] == ']' ) {
                 return substr($m[0], 1, -1);
@@ -556 +692 @@
 
         return $m[1] . $m[6];
 }
+
+// Placeholder globals.
+$wp_placeholder_idx = 0;
+$wp_placeholder_replaces = $wp_placeholder_shortcode_matches = $wp_placeholder_shortcode_in_html_tags = array();
+
+add_filter( 'the_content', 'wp_placeholder_shortcodes', 7 );
+//add_filter( 'the_content', 'wp_placeholder_comments', 7 );
+//add_filter( 'the_content', 'wp_placeholder_blobs', 7 );
+add_filter( 'the_content', 'wp_placeholder_restore', 14 );
+
+/**
+ * Filter to replace shortcodes "[shortcode param=blah]" with placeholders "[shortcode n]".
+ * Also replaces shortcodes in html tags with placeholders "<tag[shortcode n!]>".
+ */
+function wp_placeholder_shortcodes( $text ) {
+        global $wp_placeholder_replaces, $wp_placeholder_shortcode_in_html_tags;
+
+        if ( ( $tagnames = get_shortcode_tagnames( $text ) ) && ( $shortcode_regex = get_shortcode_regex( $tagnames ) ) ) {
+
+                // Replace shortcodes with placeholders of the form "[shortcode n]".
+                // Only the opening shortcode (with or without params, escaped or unescaped) is replaced, any ending shortcode ("[/shortcode]") or enclosed content isn't.
+                $text = preg_replace_callback( '/' . $shortcode_regex . '/s', 'wp_placeholder_shortcode_callback', $text );
+
+                // For security reasons, shortcodes in tags need to be passed through KSES. Do some pre-processing to make this possible for do_shortcode_tag().
+
+                // Only match attributes like 'name = "[shortcode]"' or "name = '[shortcode]'" as attributes like '[shortcode]' or 'name = [shortcode]' implies unfiltered_html.
+                $shortcode = '(\[(?:' . join( '|', array_map( 'preg_quote', $tagnames ) ) . ') \d+])';
+                $attr_with_shortcode = '(?:' . '"[^"]*' . $shortcode . '[^"]*"' . "|'[^']*" . $shortcode . "[^']*'" . ')+';
+                $possible_attrs = '(?:[^>"\']|"[^"]*"|\'[^\']*\')*';
+
+                $html_regex = '<[A-Za-z][A-Za-z\d]*\s+' . $possible_attrs . $attr_with_shortcode . $possible_attrs . '>'; 
+
+                // Replace tags containing shortcodes with placeholders of the form "<tag[shortcode n!]>".
+                $text = preg_replace_callback( '/' . $html_regex . '/s', 'wp_placeholder_shortcode_in_html_tags_callback', $text );
+        }
+
+        return $text;
+}
+
+/**
+ * preg_replace callback to replace shortcode "[shortcode param=blah]" with placeholder "[shortcode n]".
+ */
+function wp_placeholder_shortcode_callback( $matches ) {
+        global $wp_placeholder_idx, $wp_placeholder_replaces, $wp_placeholder_shortcode_matches;
+
+        $repl_shortcode = $matches[2] . ' ' . $wp_placeholder_idx++;
+        if ( $matches[5] !== '' ) {
+                // Recurse into content.
+                if ( ( $tagnames = get_shortcode_tagnames( $matches[5] ) ) && ( $shortcode_regex = get_shortcode_regex( $tagnames ) ) ) {
+                        $matches[5] = preg_replace_callback( '/' . $shortcode_regex . '/s', 'wp_placeholder_shortcode_callback', $matches[5] );
+                }
+                $repl = '[' . $repl_shortcode . ']' . $matches[5] . '[/' . $matches[2] . ']';
+        } else {
+                $repl = '[' . $repl_shortcode . ']';
+        }
+        $current_filter = current_filter();
+        $wp_placeholder_replaces[$current_filter]['['][$repl] = $matches[0];
+        $wp_placeholder_shortcode_matches[$current_filter][$repl_shortcode] = $matches;
+
+        return $repl;
+}
+
+/**
+ * preg_replace callback to replace html tag "<tag attrib... [shortcode n1] ...attrib... [shortcode n2]...>" with placeholder "<tag[shortcode n1!]>".
+ */
+function wp_placeholder_shortcode_in_html_tags_callback( $matches ) {
+        global $wp_placeholder_idx, $wp_placeholder_replaces, $wp_placeholder_shortcode_in_html_tags;
+
+        $shortcode = '';
+        if ( $matches[1] !== '' ) {
+                $shortcode = $matches[1];
+        } elseif ( $matches[2] !== '' ) {
+                $shortcode = $matches[2];
+        } elseif ( $matches[3] !== '' ) {
+                $shortcode = $matches[3];
+        }
+        if ( $shortcode ) {
+                $html_tag = substr( $matches[0], 0, strpos( $matches[0], ' ' ) );
+                $repl = $html_tag . substr( $shortcode, 0, -1 ) . '!]>';
+                $current_filter = current_filter();
+                $wp_placeholder_replaces[$current_filter]['<'][$repl] = $matches[0];
+                $wp_placeholder_shortcode_in_html_tags[$current_filter][$repl] = $matches[0];
+        } else {
+                $repl = $matches[0];
+        }
+
+        return $repl;
+}
+
+/*
+ * Filter to replace comment tags with placeholders "<!--cn-->".
+ */
+function wp_placeholder_comments( $text ) {
+        $comment_regex =
+                  '<!'           // Start of comment.
+                . '(?:'         // Unroll the loop: Consume everything until --> is found.
+                .     '-(?!->)' // Dash not followed by end of comment.
+                .     '[^\-]*+' // Consume non-dashes.
+                . ')*+'         // Loop possessively.
+                . '(?:-->)?';   // End of comment. If not found, match all input.
+
+        $text = preg_replace_callback( '/' . $comment_regex . '/s', 'wp_placeholder_comment_callback', $text );
+
+        return $text;
+}
+
+/**
+ * preg_replace callback to replace comment html "<!--blah-->" with placeholder "<!--cn-->".
+ */
+function wp_placeholder_comment_callback( $matches ) {
+        return wp_placeholder_prefix_callback( $matches, 'c' );
+}
+
+/*
+ * Filter to replace blob-like html tags with placeholders "<!--bn-->".
+ */
+function wp_placeholder_blobs( $text ) {
+        $blob_regex = '<(audio|input|object|script|select|style|textarea|video)(?:(?:[^>"\']*|"[^"]*"|\'[^\']*\')*)?' . '>.*?<\/\\1\s*>';
+
+        $text = preg_replace_callback( '/' . $blob_regex . '/s', 'wp_placeholder_blob_callback', $text );
+
+        return $text;
+}
+
+/**
+ * preg_replace callback to replace blob-like html "<script ...>...</script>" with placeholder "<!--bn-->".
+ */
+function wp_placeholder_blob_callback( $matches ) {
+        return wp_placeholder_prefix_callback( $matches, 'b' );
+}
+
+/**
+ * Helper to do comment-like placeholders with prefix ("<!--pn-->").
+ */
+function wp_placeholder_prefix_callback( $matches, $prefix ) {
+        global $wp_placeholder_idx, $wp_placeholder_replaces;
+
+        $repl = '<!--' . $prefix . $wp_placeholder_idx++ . '-->';
+        $wp_placeholder_replaces[current_filter()][$prefix][$repl] = $matches[0];
+
+        return $repl;
+}
+
+/**
+ * Restore placeholder original text.
+ */
+function wp_placeholder_restore( $text, $prefix = null ) {
+        global $wp_placeholder_replaces;
+
+        $current_filter = current_filter();
+
+        if ( ! empty( $wp_placeholder_replaces[$current_filter] ) ) {
+                $replaces = &$wp_placeholder_replaces[$current_filter];
+                if ( $prefix ) {
+                        // If given as array then should be careful to reverse ordering of nested replacements.
+                        $pfs = is_array( $prefix ) ? $prefix : array( $prefix );
+                        foreach ( $pfs as $pf ) {
+                                if ( isset( $replaces[$pf] ) ) {
+                                        $text = str_replace( array_keys( $replaces[$pf] ), $replaces[$pf], $text );
+                                        unset( $replaces[$pf] );
+                                }
+                        }
+                } else {
+                        // Do it backwards to ensure nested replacements are replaced.
+                        foreach ( array_reverse( $replaces ) as $repl ) {
+                                $text = str_replace( array_keys( $repl ), $repl, $text );
+                        }
+                        $replaces = array();
+                }
+        }
+
+        return $text;
+}