tag.
+ * 'p' => FALSE,
+ * // Allows the following attributes on the tag:
+ * // - 'href', with any value;
+ * // - 'rel', with the value 'nofollow' value.
+ * 'a' => array(
+ * 'href' => TRUE,
+ * 'rel' => array('nofollow' => TRUE),
+ * ),
+ * // Only allows the 'src' and 'alt' attributes on the
',
+ )
),
),
));
@@ -76,6 +79,7 @@ function testGetJSSettings() {
// Default toolbar.
$expected_config = $this->getDefaultInternalConfig() + array(
+ 'allowedContent' => $this->getDefaultAllowedContentConfig(),
'toolbar' => $this->getDefaultToolbarConfig(),
'contentsCss' => $this->getDefaultContentsCssConfig(),
'extraPlugins' => '',
@@ -83,6 +87,7 @@ function testGetJSSettings() {
'stylesSet' => FALSE,
'drupalExternalPlugins' => array(),
);
+ ksort($expected_config);
$this->assertIdentical($expected_config, $this->ckeditor->getJSSettings($editor), 'Generated JS settings are correct for default configuration.');
// Customize the configuration: add button, have two contextually enabled
@@ -102,15 +107,81 @@ function testGetJSSettings() {
$expected_config['drupalExternalPlugins']['llama_contextual_and_button'] = file_create_url('core/modules/ckeditor/tests/modules/js/llama_contextual_and_button.js');
$expected_config['contentsCss'][] = file_create_url('core/modules/ckeditor/tests/modules/ckeditor_test.css');
$expected_config['keystrokes'] = array(array(1114187, 'link'), array(1114188, NULL));
- $this->assertEqual($expected_config, $this->ckeditor->getJSSettings($editor), 'Generated JS settings are correct for customized configuration.');
+ ksort($expected_config);
+ $this->assertIdentical($expected_config, $this->ckeditor->getJSSettings($editor), 'Generated JS settings are correct for customized configuration.');
- // Change the allowed HTML tags; the "format_tags" setting for CKEditor
- // should automatically be updated as well.
+ // Change the allowed HTML tags; the "allowedContent" and "format_tags"
+ // settings for CKEditor should automatically be updated as well.
$format = entity_load('filter_format', 'filtered_html');
$format->filters('filter_html')->settings['allowed_html'] .= '
';
$format->save();
+ $expected_config['allowedContent']['pre'] = array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE);
+ $expected_config['allowedContent']['h3'] = array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE);
$expected_config['format_tags'] = 'p;h3;h4;h5;h6;pre';
- $this->assertEqual($expected_config, $this->ckeditor->getJSSettings($editor), 'Generated JS settings are correct for customized configuration.');
+ $this->assertIdentical($expected_config, $this->ckeditor->getJSSettings($editor), 'Generated JS settings are correct for customized configuration.');
+
+ // Disable the filter_html filter: allow *all *tags.
+ $format->setFilterConfig('filter_html', array('status' => 0));
+ $format->save();
+ $expected_config['allowedContent'] = TRUE;
+ $expected_config['format_tags'] = 'p;h1;h2;h3;h4;h5;h6;pre';
+ $this->assertIdentical($expected_config, $this->ckeditor->getJSSettings($editor), 'Generated JS settings are correct for customized configuration.');
+
+ // Enable the filter_test_restrict_tags_and_attributes filter.
+ $format->setFilterConfig('filter_test_restrict_tags_and_attributes', array(
+ 'status' => 1,
+ 'settings' => array(
+ 'restrictions' => array(
+ 'allowed' => array(
+ 'p' => TRUE,
+ 'a' => array(
+ 'href' => TRUE,
+ 'rel' => array('nofollow' => TRUE),
+ 'class' => array('external' => TRUE),
+ 'target' => array('_blank' => FALSE),
+ ),
+ 'span' => array(
+ 'class' => array('dodo' => FALSE),
+ 'property' => array('dc:*' => TRUE),
+ 'rel' => array('foaf:*' => FALSE),
+ ),
+ '*' => array(
+ 'style' => FALSE,
+ 'class' => array('is-a-hipster-llama' => TRUE, 'and-more' => TRUE),
+ 'data-*' => TRUE,
+ ),
+ 'del' => FALSE,
+ )
+ ),
+ ),
+ ));
+ $format->save();
+ $expected_config['allowedContent'] = array(
+ 'p' => array(
+ 'attributes' => TRUE,
+ 'styles' => FALSE,
+ 'classes' => 'is-a-hipster-llama,and-more',
+ ),
+ 'a' => array(
+ 'attributes' => 'href,rel,class,target',
+ 'classes' => 'external',
+ ),
+ 'span' => array(
+ 'attributes' => 'class,property,rel',
+ ),
+ '*' => array(
+ 'attributes' => 'class,data-*',
+ 'classes' => 'is-a-hipster-llama,and-more',
+ ),
+ 'del' => array(
+ 'attributes' => FALSE,
+ 'styles' => FALSE,
+ 'classes' => FALSE,
+ ),
+ );
+ $expected_config['format_tags'] = 'p';
+ ksort($expected_config);
+ $this->assertIdentical($expected_config, $this->ckeditor->getJSSettings($editor), 'Generated JS settings are correct for customized configuration.');
}
/**
@@ -166,6 +237,7 @@ function testInternalGetConfig() {
// Default toolbar.
$expected = $this->getDefaultInternalConfig();
+ $expected['allowedContent'] = $this->getDefaultAllowedContentConfig();
$this->assertIdentical($expected, $internal_plugin->getConfig($editor), '"Internal" plugin configuration built correctly for default toolbar.');
// Format dropdown/button enabled: new setting should be present.
@@ -236,6 +308,18 @@ protected function getDefaultInternalConfig() {
);
}
+ protected function getDefaultAllowedContentConfig() {
+ return array(
+ 'h4' => array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE),
+ 'h5' => array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE),
+ 'h6' => array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE),
+ 'p' => array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE),
+ 'br' => array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE),
+ 'strong' => array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE),
+ 'a' => array('attributes' => TRUE, 'styles' => FALSE, 'classes' => TRUE),
+ );
+ }
+
protected function getDefaultToolbarConfig() {
return array(
0 => array('items' => array('Bold', 'Italic')),
diff --git a/core/modules/filter/filter.module b/core/modules/filter/filter.module
index 263afb522f1e389acd68d485af5f4e4dfabdc16a..1b90cdea323b0f502b452793cdd1df6ce97588f4 100644
--- a/core/modules/filter/filter.module
+++ b/core/modules/filter/filter.module
@@ -415,6 +415,154 @@ function filter_get_filter_types_by_format($format_id) {
return array_unique($filter_types);
}
+/**
+ * Retrieve all HTML restrictions (tags and attributes) for a given text format.
+ *
+ * Note that restrictions applied to the "*" tag (the wildcard tag, i.e. all
+ * tags) are treated just like any other HTML tag. That means that any
+ * restrictions applied to it are not automatically applied to all other tags.
+ * It is up to the caller to handle this in whatever way it sees fit; this way
+ * no information granularity is lost.
+ *
+ * @param string $format_id
+ * A text format ID.
+ *
+ * @return array|FALSE
+ * An structured array as returned by FilterInterface::getHTMLRestrictions(),
+ * but with the intersection of all filters in this text format.
+ * Will either indicate blacklisting of tags or whitelisting of tags. In the
+ * latter case, it's possible that restrictions on attributes are also stored.
+ * FALSE means there are no HTML restrictions.
+ */
+function filter_get_html_restrictions_by_format($format_id) {
+ $format = filter_format_load($format_id);
+
+ // Ignore filters that are disabled or don't have HTML restrictions.
+ $filters = array_filter($format->filters()->getAll(), function($filter) {
+ if (!$filter->status) {
+ return FALSE;
+ }
+ if ($filter->getType() === FILTER_TYPE_HTML_RESTRICTOR && $filter->getHTMLRestrictions() !== FALSE) {
+ return TRUE;
+ }
+ return FALSE;
+ });
+
+ if (empty($filters)) {
+ return FALSE;
+ }
+ else {
+ // From the set of remaining filters (they were filtered by array_filter()
+ // above), collect the list of tags and attributes that are allowed by all
+ // filters, i.e. the intersection of all allowed tags and attributes.
+ $restrictions = array_reduce($filters, function($restrictions, $filter) {
+ $new_restrictions = $filter->getHTMLRestrictions();
+
+ // The first filter with HTML restrictions provides the initial set.
+ if (!isset($restrictions)) {
+ return $new_restrictions;
+ }
+ // Subsequent filters with an "allowed html" setting must be intersected
+ // with the existing set, to ensure we only end up with the tags that are
+ // allowed by *all* filters with an "allowed html" setting.
+ else {
+ // Track the union of forbidden (blacklisted) tags.
+ if (isset($new_restrictions['forbidden_tags'])) {
+ if (!isset($restrictions['forbidden_tags'])) {
+ $restrictions['forbidden_tags'] = $new_restrictions['forbidden_tags'];
+ }
+ else {
+ $restrictions['forbidden_tags'] = array_unique(array_merge($restrictions['forbidden_tags'], $new_restrictions['forbidden_tags']));
+ }
+ }
+
+ // Track the intersection of allowed (whitelisted) tags.
+ if (isset($restrictions['allowed'])) {
+ $intersection = $restrictions['allowed'];
+ foreach ($intersection as $tag => $attributes) {
+ // If the current tag is not whitelisted by the new filter, then
+ // it's outside of the intersection.
+ if (!array_key_exists($tag, $new_restrictions['allowed'])) {
+ // The exception is the asterisk (which applies to all tags): it
+ // does not need to be whitelisted by every filter in order to be
+ // used; not every filter needs attribute restrictions on all tags.
+ if ($tag === '*') {
+ continue;
+ }
+ unset($intersection[$tag]);
+ }
+ // The tag is in the intersection, but now we must calculate the
+ // intersection of the allowed attributes.
+ else {
+ $current_attributes = $intersection[$tag];
+ $new_attributes = $new_restrictions['allowed'][$tag];
+ // The current intersection does not allow any attributes, never
+ // allow.
+ if (!is_array($current_attributes) && $current_attributes == FALSE) {
+ continue;
+ }
+ // The new filter allows less attributes (all -> list or none).
+ else if (!is_array($current_attributes) && $current_attributes == TRUE && ($new_attributes == FALSE || is_array($new_attributes))) {
+ $intersection[$tag] = $new_attributes;
+ }
+ // The new filter allows less attributes (list -> none).
+ else if (is_array($current_attributes) && $new_attributes == FALSE) {
+ $intersection[$tag] = $new_attributes;
+ }
+ // The new filter allows more attributes; retain current.
+ else if (is_array($current_attributes) && $new_attributes == TRUE) {
+ continue;
+ }
+ // The new filter allows the same attributes; retain current.
+ else if ($current_attributes == $new_attributes) {
+ continue;
+ }
+ // Both list an array of attribute values; do an intersection,
+ // where we take into account that a value of:
+ // - TRUE means the attribute value is allowed;
+ // - FALSE means the attribute value is forbidden;
+ // hence we keep the ANDed result.
+ else {
+ $intersection[$tag] = array_intersect_key($intersection[$tag], $new_attributes);
+ foreach (array_keys($intersection[$tag]) as $attribute_value) {
+ $intersection[$tag][$attribute_value] = $intersection[$tag][$attribute_value] && $new_attributes[$attribute_value];
+ }
+ }
+ }
+ }
+ $restrictions['allowed'] = $intersection;
+ }
+
+ return $restrictions;
+ }
+ }, NULL);
+
+ // Simplification: if we have both a (intersected) whitelist and a (unioned)
+ // blacklist, then remove any tags from the whitelist that also exist in the
+ // blacklist. Now the whitelist alone expresses all tag-level restrictions,
+ // and we can delete the blacklist.
+ if (isset($restrictions['allowed']) && isset($restrictions['forbidden_tags'])) {
+ foreach ($restrictions['forbidden_tags'] as $tag) {
+ if (isset($restrictions['allowed'][$tag])) {
+ unset($restrictions['allowed'][$tag]);
+ }
+ }
+ unset($restrictions['forbidden_tags']);
+ }
+
+ // Simplification: if the only remaining allowed tag is the asterisk (which
+ // contains attribute restrictions that apply to all tags), and only
+ // whitelisting filters were used, then effectively nothing is allowed.
+ if (isset($restrictions['allowed'])) {
+ if (count($restrictions['allowed']) === 1 && array_key_exists('*', $restrictions['allowed']) && !isset($restrictions['forbidden_tags'])) {
+ $restrictions['allowed'] = array();
+ }
+ }
+
+ return $restrictions;
+ }
+}
+
/**
* Returns the ID of the fallback text format that all users have access to.
*
diff --git a/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtml.php b/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtml.php
index d77e37eb90993b2585f4a871721c2b13669547ed..177ccdb4045d65ee5aeeaf3261f1a8b561a34a33 100644
--- a/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtml.php
+++ b/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtml.php
@@ -65,6 +65,21 @@ public function process($text, $langcode, $cache, $cache_id) {
return _filter_html($text, $this);
}
+ /**
+ * {@inheritdoc}
+ */
+ public function getHTMLRestrictions() {
+ $restrictions = array('allowed' => array());
+ $tags = preg_split('/\s+|<|>/', $this->settings['allowed_html'], -1, PREG_SPLIT_NO_EMPTY);
+ // List the allowed HTML tags.
+ foreach ($tags as $tag) {
+ $restrictions['allowed'][$tag] = TRUE;
+ }
+ // The 'style' and 'on*' ('onClick' etc.) attributes are always forbidden.
+ $restrictions['allowed']['*'] = array('style' => FALSE, 'on*' => FALSE);
+ return $restrictions;
+ }
+
/**
* {@inheritdoc}
*/
diff --git a/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtmlEscape.php b/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtmlEscape.php
index f4a3694179139c76e24b8cd0196c4cb154524b69..24e3114d27a4be439d4aa1e636c53aa7598a33e7 100644
--- a/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtmlEscape.php
+++ b/core/modules/filter/lib/Drupal/filter/Plugin/Filter/FilterHtmlEscape.php
@@ -31,6 +31,14 @@ public function process($text, $langcode, $cache, $cache_id) {
return _filter_html_escape($text);
}
+ /**
+ * {@inheritdoc}
+ */
+ public function getHTMLRestrictions() {
+ // Nothing is allowed.
+ return array('allowed' => array());
+ }
+
/**
* {@inheritdoc}
*/
diff --git a/core/modules/filter/lib/Drupal/filter/Plugin/FilterBase.php b/core/modules/filter/lib/Drupal/filter/Plugin/FilterBase.php
index ab56c911613644955e04dc65f7aaf121b79a8f15..2e80bd067d126bae5df319fcf756032ff64dd851 100644
--- a/core/modules/filter/lib/Drupal/filter/Plugin/FilterBase.php
+++ b/core/modules/filter/lib/Drupal/filter/Plugin/FilterBase.php
@@ -147,6 +147,13 @@ public function prepare($text, $langcode, $cache, $cache_id) {
return $text;
}
+ /**
+ * {@inheritdoc}
+ */
+ public function getHTMLRestrictions() {
+ return FALSE;
+ }
+
/**
* {@inheritdoc}
*/
diff --git a/core/modules/filter/lib/Drupal/filter/Plugin/FilterInterface.php b/core/modules/filter/lib/Drupal/filter/Plugin/FilterInterface.php
index 0857139f0b12955da4db24c6d121744f81f748f7..5b231a991ae8364ab4d627cf2535d27c545848d6 100644
--- a/core/modules/filter/lib/Drupal/filter/Plugin/FilterInterface.php
+++ b/core/modules/filter/lib/Drupal/filter/Plugin/FilterInterface.php
@@ -175,6 +175,100 @@ public function prepare($text, $langcode, $cache, $cache_id);
*/
public function process($text, $langcode, $cache, $cache_id);
+ /**
+ * Returns HTML allowed by this filter's configuration.
+ *
+ * May be implemented by filters of the type FILTER_TYPE_HTML_RESTRICTOR, this
+ * won't be used for filters of other types; they should just return FALSE.
+ *
+ * This callback function is only necessary for filters that strip away HTML
+ * tags (and possibly attributes) and allows other modules to gain insight in
+ * a generic manner into which HTML tags and attributes are allowed by a
+ * format.
+ *
+ * @return array|FALSE
+ * A nested array with *either* of the following keys:
+ * - 'allowed': (optional) the allowed tags as keys, and for each of those
+ * tags (keys) either of the following values:
+ * - TRUE to indicate any attribute is allowed
+ * - FALSE to indicate no attributes are allowed
+ * - an array to convey attribute restrictions: the keys must be
+ * attribute names (which may use a wildcard, e.g. "data-*"), the
+ * possible values are similar to the above:
+ * - TRUE to indicate any attribute value is allowed
+ * - FALSE to indicate the attribute is forbidden
+ * - an array to convey attribute value restrictions: the key must
+ * be attribute values (which may use a wildcard, e.g. "xsd:*"),
+ * the possible values are TRUE or FALSE: to mark the attribute
+ * value as allowed or forbidden, respectively
+ * - 'forbidden_tags': (optional) the forbidden tags
+ *
+ * There is one special case: the "wildcard tag", "*": any attribute
+ * restrictions on that pseudotag apply to all tags.
+ *
+ * If no restrictions apply, then FALSE must be returned.
+ *
+ * Here is a concrete example, for a very granular filter:
+ * @code
+ * array(
+ * 'allowed' => array(
+ * // Allows any attribute with any value on the