921 lines
31 KiB
PHP
921 lines
31 KiB
PHP
<?php
|
|
|
|
/**
|
|
* Configuration object that triggers customizable behavior.
|
|
*
|
|
* @warning This class is strongly defined: that means that the class
|
|
* will fail if an undefined directive is retrieved or set.
|
|
*
|
|
* @note Many classes that could (although many times don't) use the
|
|
* configuration object make it a mandatory parameter. This is
|
|
* because a configuration object should always be forwarded,
|
|
* otherwise, you run the risk of missing a parameter and then
|
|
* being stumped when a configuration directive doesn't work.
|
|
*
|
|
* @todo Reconsider some of the public member variables
|
|
*/
|
|
class HTMLPurifier_Config
|
|
{
|
|
|
|
/**
|
|
* HTML Purifier's version
|
|
* @type string
|
|
*/
|
|
public $version = '4.15.0';
|
|
|
|
/**
|
|
* Whether or not to automatically finalize
|
|
* the object if a read operation is done.
|
|
* @type bool
|
|
*/
|
|
public $autoFinalize = true;
|
|
|
|
// protected member variables
|
|
|
|
/**
|
|
* Namespace indexed array of serials for specific namespaces.
|
|
* @see getSerial() for more info.
|
|
* @type string[]
|
|
*/
|
|
protected $serials = array();
|
|
|
|
/**
|
|
* Serial for entire configuration object.
|
|
* @type string
|
|
*/
|
|
protected $serial;
|
|
|
|
/**
|
|
* Parser for variables.
|
|
* @type HTMLPurifier_VarParser_Flexible
|
|
*/
|
|
protected $parser = null;
|
|
|
|
/**
|
|
* Reference HTMLPurifier_ConfigSchema for value checking.
|
|
* @type HTMLPurifier_ConfigSchema
|
|
* @note This is public for introspective purposes. Please don't
|
|
* abuse!
|
|
*/
|
|
public $def;
|
|
|
|
/**
|
|
* Indexed array of definitions.
|
|
* @type HTMLPurifier_Definition[]
|
|
*/
|
|
protected $definitions;
|
|
|
|
/**
|
|
* Whether or not config is finalized.
|
|
* @type bool
|
|
*/
|
|
protected $finalized = false;
|
|
|
|
/**
|
|
* Property list containing configuration directives.
|
|
* @type array
|
|
*/
|
|
protected $plist;
|
|
|
|
/**
|
|
* Whether or not a set is taking place due to an alias lookup.
|
|
* @type bool
|
|
*/
|
|
private $aliasMode;
|
|
|
|
/**
|
|
* Set to false if you do not want line and file numbers in errors.
|
|
* (useful when unit testing). This will also compress some errors
|
|
* and exceptions.
|
|
* @type bool
|
|
*/
|
|
public $chatty = true;
|
|
|
|
/**
|
|
* Current lock; only gets to this namespace are allowed.
|
|
* @type string
|
|
*/
|
|
private $lock;
|
|
|
|
/**
|
|
* Constructor
|
|
* @param HTMLPurifier_ConfigSchema $definition ConfigSchema that defines
|
|
* what directives are allowed.
|
|
* @param HTMLPurifier_PropertyList $parent
|
|
*/
|
|
public function __construct($definition, $parent = null)
|
|
{
|
|
$parent = $parent ? $parent : $definition->defaultPlist;
|
|
$this->plist = new HTMLPurifier_PropertyList($parent);
|
|
$this->def = $definition; // keep a copy around for checking
|
|
$this->parser = new HTMLPurifier_VarParser_Flexible();
|
|
}
|
|
|
|
/**
|
|
* Convenience constructor that creates a config object based on a mixed var
|
|
* @param mixed $config Variable that defines the state of the config
|
|
* object. Can be: a HTMLPurifier_Config() object,
|
|
* an array of directives based on loadArray(),
|
|
* or a string filename of an ini file.
|
|
* @param HTMLPurifier_ConfigSchema $schema Schema object
|
|
* @return HTMLPurifier_Config Configured object
|
|
*/
|
|
public static function create($config, $schema = null)
|
|
{
|
|
if ($config instanceof HTMLPurifier_Config) {
|
|
// pass-through
|
|
return $config;
|
|
}
|
|
if (!$schema) {
|
|
$ret = HTMLPurifier_Config::createDefault();
|
|
} else {
|
|
$ret = new HTMLPurifier_Config($schema);
|
|
}
|
|
if (is_string($config)) {
|
|
$ret->loadIni($config);
|
|
} elseif (is_array($config)) $ret->loadArray($config);
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Creates a new config object that inherits from a previous one.
|
|
* @param HTMLPurifier_Config $config Configuration object to inherit from.
|
|
* @return HTMLPurifier_Config object with $config as its parent.
|
|
*/
|
|
public static function inherit(HTMLPurifier_Config $config)
|
|
{
|
|
return new HTMLPurifier_Config($config->def, $config->plist);
|
|
}
|
|
|
|
/**
|
|
* Convenience constructor that creates a default configuration object.
|
|
* @return HTMLPurifier_Config default object.
|
|
*/
|
|
public static function createDefault()
|
|
{
|
|
$definition = HTMLPurifier_ConfigSchema::instance();
|
|
$config = new HTMLPurifier_Config($definition);
|
|
return $config;
|
|
}
|
|
|
|
/**
|
|
* Retrieves a value from the configuration.
|
|
*
|
|
* @param string $key String key
|
|
* @param mixed $a
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function get($key, $a = null)
|
|
{
|
|
if ($a !== null) {
|
|
$this->triggerError(
|
|
"Using deprecated API: use \$config->get('$key.$a') instead",
|
|
E_USER_WARNING
|
|
);
|
|
$key = "$key.$a";
|
|
}
|
|
if (!$this->finalized) {
|
|
$this->autoFinalize();
|
|
}
|
|
if (!isset($this->def->info[$key])) {
|
|
// can't add % due to SimpleTest bug
|
|
$this->triggerError(
|
|
'Cannot retrieve value of undefined directive ' . htmlspecialchars($key),
|
|
E_USER_WARNING
|
|
);
|
|
return;
|
|
}
|
|
if (isset($this->def->info[$key]->isAlias)) {
|
|
$d = $this->def->info[$key];
|
|
$this->triggerError(
|
|
'Cannot get value from aliased directive, use real name ' . $d->key,
|
|
E_USER_ERROR
|
|
);
|
|
return;
|
|
}
|
|
if ($this->lock) {
|
|
list($ns) = explode('.', $key);
|
|
if ($ns !== $this->lock) {
|
|
$this->triggerError(
|
|
'Cannot get value of namespace ' . $ns . ' when lock for ' .
|
|
$this->lock .
|
|
' is active, this probably indicates a Definition setup method ' .
|
|
'is accessing directives that are not within its namespace',
|
|
E_USER_ERROR
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
return $this->plist->get($key);
|
|
}
|
|
|
|
/**
|
|
* Retrieves an array of directives to values from a given namespace
|
|
*
|
|
* @param string $namespace String namespace
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getBatch($namespace)
|
|
{
|
|
if (!$this->finalized) {
|
|
$this->autoFinalize();
|
|
}
|
|
$full = $this->getAll();
|
|
if (!isset($full[$namespace])) {
|
|
$this->triggerError(
|
|
'Cannot retrieve undefined namespace ' .
|
|
htmlspecialchars($namespace),
|
|
E_USER_WARNING
|
|
);
|
|
return;
|
|
}
|
|
return $full[$namespace];
|
|
}
|
|
|
|
/**
|
|
* Returns a SHA-1 signature of a segment of the configuration object
|
|
* that uniquely identifies that particular configuration
|
|
*
|
|
* @param string $namespace Namespace to get serial for
|
|
*
|
|
* @return string
|
|
* @note Revision is handled specially and is removed from the batch
|
|
* before processing!
|
|
*/
|
|
public function getBatchSerial($namespace)
|
|
{
|
|
if (empty($this->serials[$namespace])) {
|
|
$batch = $this->getBatch($namespace);
|
|
unset($batch['DefinitionRev']);
|
|
$this->serials[$namespace] = sha1(serialize($batch));
|
|
}
|
|
return $this->serials[$namespace];
|
|
}
|
|
|
|
/**
|
|
* Returns a SHA-1 signature for the entire configuration object
|
|
* that uniquely identifies that particular configuration
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getSerial()
|
|
{
|
|
if (empty($this->serial)) {
|
|
$this->serial = sha1(serialize($this->getAll()));
|
|
}
|
|
return $this->serial;
|
|
}
|
|
|
|
/**
|
|
* Retrieves all directives, organized by namespace
|
|
*
|
|
* @warning This is a pretty inefficient function, avoid if you can
|
|
*/
|
|
public function getAll()
|
|
{
|
|
if (!$this->finalized) {
|
|
$this->autoFinalize();
|
|
}
|
|
$ret = array();
|
|
foreach ($this->plist->squash() as $name => $value) {
|
|
list($ns, $key) = explode('.', $name, 2);
|
|
$ret[$ns][$key] = $value;
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Sets a value to configuration.
|
|
*
|
|
* @param string $key key
|
|
* @param mixed $value value
|
|
* @param mixed $a
|
|
*/
|
|
public function set($key, $value, $a = null)
|
|
{
|
|
if (strpos($key, '.') === false) {
|
|
$namespace = $key;
|
|
$directive = $value;
|
|
$value = $a;
|
|
$key = "$key.$directive";
|
|
$this->triggerError("Using deprecated API: use \$config->set('$key', ...) instead", E_USER_NOTICE);
|
|
} else {
|
|
list($namespace) = explode('.', $key);
|
|
}
|
|
if ($this->isFinalized('Cannot set directive after finalization')) {
|
|
return;
|
|
}
|
|
if (!isset($this->def->info[$key])) {
|
|
$this->triggerError(
|
|
'Cannot set undefined directive ' . htmlspecialchars($key) . ' to value',
|
|
E_USER_WARNING
|
|
);
|
|
return;
|
|
}
|
|
$def = $this->def->info[$key];
|
|
|
|
if (isset($def->isAlias)) {
|
|
if ($this->aliasMode) {
|
|
$this->triggerError(
|
|
'Double-aliases not allowed, please fix '.
|
|
'ConfigSchema bug with' . $key,
|
|
E_USER_ERROR
|
|
);
|
|
return;
|
|
}
|
|
$this->aliasMode = true;
|
|
$this->set($def->key, $value);
|
|
$this->aliasMode = false;
|
|
$this->triggerError("$key is an alias, preferred directive name is {$def->key}", E_USER_NOTICE);
|
|
return;
|
|
}
|
|
|
|
// Raw type might be negative when using the fully optimized form
|
|
// of stdClass, which indicates allow_null == true
|
|
$rtype = is_int($def) ? $def : $def->type;
|
|
if ($rtype < 0) {
|
|
$type = -$rtype;
|
|
$allow_null = true;
|
|
} else {
|
|
$type = $rtype;
|
|
$allow_null = isset($def->allow_null);
|
|
}
|
|
|
|
try {
|
|
$value = $this->parser->parse($value, $type, $allow_null);
|
|
} catch (HTMLPurifier_VarParserException $e) {
|
|
$this->triggerError(
|
|
'Value for ' . $key . ' is of invalid type, should be ' .
|
|
HTMLPurifier_VarParser::getTypeName($type),
|
|
E_USER_WARNING
|
|
);
|
|
return;
|
|
}
|
|
if (is_string($value) && is_object($def)) {
|
|
// resolve value alias if defined
|
|
if (isset($def->aliases[$value])) {
|
|
$value = $def->aliases[$value];
|
|
}
|
|
// check to see if the value is allowed
|
|
if (isset($def->allowed) && !isset($def->allowed[$value])) {
|
|
$this->triggerError(
|
|
'Value not supported, valid values are: ' .
|
|
$this->_listify($def->allowed),
|
|
E_USER_WARNING
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
$this->plist->set($key, $value);
|
|
|
|
// reset definitions if the directives they depend on changed
|
|
// this is a very costly process, so it's discouraged
|
|
// with finalization
|
|
if ($namespace == 'HTML' || $namespace == 'CSS' || $namespace == 'URI') {
|
|
$this->definitions[$namespace] = null;
|
|
}
|
|
|
|
$this->serials[$namespace] = false;
|
|
}
|
|
|
|
/**
|
|
* Convenience function for error reporting
|
|
*
|
|
* @param array $lookup
|
|
*
|
|
* @return string
|
|
*/
|
|
private function _listify($lookup)
|
|
{
|
|
$list = array();
|
|
foreach ($lookup as $name => $b) {
|
|
$list[] = $name;
|
|
}
|
|
return implode(', ', $list);
|
|
}
|
|
|
|
/**
|
|
* Retrieves object reference to the HTML definition.
|
|
*
|
|
* @param bool $raw Return a copy that has not been setup yet. Must be
|
|
* called before it's been setup, otherwise won't work.
|
|
* @param bool $optimized If true, this method may return null, to
|
|
* indicate that a cached version of the modified
|
|
* definition object is available and no further edits
|
|
* are necessary. Consider using
|
|
* maybeGetRawHTMLDefinition, which is more explicitly
|
|
* named, instead.
|
|
*
|
|
* @return HTMLPurifier_HTMLDefinition|null
|
|
*/
|
|
public function getHTMLDefinition($raw = false, $optimized = false)
|
|
{
|
|
return $this->getDefinition('HTML', $raw, $optimized);
|
|
}
|
|
|
|
/**
|
|
* Retrieves object reference to the CSS definition
|
|
*
|
|
* @param bool $raw Return a copy that has not been setup yet. Must be
|
|
* called before it's been setup, otherwise won't work.
|
|
* @param bool $optimized If true, this method may return null, to
|
|
* indicate that a cached version of the modified
|
|
* definition object is available and no further edits
|
|
* are necessary. Consider using
|
|
* maybeGetRawCSSDefinition, which is more explicitly
|
|
* named, instead.
|
|
*
|
|
* @return HTMLPurifier_CSSDefinition|null
|
|
*/
|
|
public function getCSSDefinition($raw = false, $optimized = false)
|
|
{
|
|
return $this->getDefinition('CSS', $raw, $optimized);
|
|
}
|
|
|
|
/**
|
|
* Retrieves object reference to the URI definition
|
|
*
|
|
* @param bool $raw Return a copy that has not been setup yet. Must be
|
|
* called before it's been setup, otherwise won't work.
|
|
* @param bool $optimized If true, this method may return null, to
|
|
* indicate that a cached version of the modified
|
|
* definition object is available and no further edits
|
|
* are necessary. Consider using
|
|
* maybeGetRawURIDefinition, which is more explicitly
|
|
* named, instead.
|
|
*
|
|
* @return HTMLPurifier_URIDefinition|null
|
|
*/
|
|
public function getURIDefinition($raw = false, $optimized = false)
|
|
{
|
|
return $this->getDefinition('URI', $raw, $optimized);
|
|
}
|
|
|
|
/**
|
|
* Retrieves a definition
|
|
*
|
|
* @param string $type Type of definition: HTML, CSS, etc
|
|
* @param bool $raw Whether or not definition should be returned raw
|
|
* @param bool $optimized Only has an effect when $raw is true. Whether
|
|
* or not to return null if the result is already present in
|
|
* the cache. This is off by default for backwards
|
|
* compatibility reasons, but you need to do things this
|
|
* way in order to ensure that caching is done properly.
|
|
* Check out enduser-customize.html for more details.
|
|
* We probably won't ever change this default, as much as the
|
|
* maybe semantics is the "right thing to do."
|
|
*
|
|
* @throws HTMLPurifier_Exception
|
|
* @return HTMLPurifier_Definition|null
|
|
*/
|
|
public function getDefinition($type, $raw = false, $optimized = false)
|
|
{
|
|
if ($optimized && !$raw) {
|
|
throw new HTMLPurifier_Exception("Cannot set optimized = true when raw = false");
|
|
}
|
|
if (!$this->finalized) {
|
|
$this->autoFinalize();
|
|
}
|
|
// temporarily suspend locks, so we can handle recursive definition calls
|
|
$lock = $this->lock;
|
|
$this->lock = null;
|
|
$factory = HTMLPurifier_DefinitionCacheFactory::instance();
|
|
$cache = $factory->create($type, $this);
|
|
$this->lock = $lock;
|
|
if (!$raw) {
|
|
// full definition
|
|
// ---------------
|
|
// check if definition is in memory
|
|
if (!empty($this->definitions[$type])) {
|
|
$def = $this->definitions[$type];
|
|
// check if the definition is setup
|
|
if ($def->setup) {
|
|
return $def;
|
|
} else {
|
|
$def->setup($this);
|
|
if ($def->optimized) {
|
|
$cache->add($def, $this);
|
|
}
|
|
return $def;
|
|
}
|
|
}
|
|
// check if definition is in cache
|
|
$def = $cache->get($this);
|
|
if ($def) {
|
|
// definition in cache, save to memory and return it
|
|
$this->definitions[$type] = $def;
|
|
return $def;
|
|
}
|
|
// initialize it
|
|
$def = $this->initDefinition($type);
|
|
// set it up
|
|
$this->lock = $type;
|
|
$def->setup($this);
|
|
$this->lock = null;
|
|
// save in cache
|
|
$cache->add($def, $this);
|
|
// return it
|
|
return $def;
|
|
} else {
|
|
// raw definition
|
|
// --------------
|
|
// check preconditions
|
|
$def = null;
|
|
if ($optimized) {
|
|
if (is_null($this->get($type . '.DefinitionID'))) {
|
|
// fatally error out if definition ID not set
|
|
throw new HTMLPurifier_Exception(
|
|
"Cannot retrieve raw version without specifying %$type.DefinitionID"
|
|
);
|
|
}
|
|
}
|
|
if (!empty($this->definitions[$type])) {
|
|
$def = $this->definitions[$type];
|
|
if ($def->setup && !$optimized) {
|
|
$extra = $this->chatty ?
|
|
" (try moving this code block earlier in your initialization)" :
|
|
"";
|
|
throw new HTMLPurifier_Exception(
|
|
"Cannot retrieve raw definition after it has already been setup" .
|
|
$extra
|
|
);
|
|
}
|
|
if ($def->optimized === null) {
|
|
$extra = $this->chatty ? " (try flushing your cache)" : "";
|
|
throw new HTMLPurifier_Exception(
|
|
"Optimization status of definition is unknown" . $extra
|
|
);
|
|
}
|
|
if ($def->optimized !== $optimized) {
|
|
$msg = $optimized ? "optimized" : "unoptimized";
|
|
$extra = $this->chatty ?
|
|
" (this backtrace is for the first inconsistent call, which was for a $msg raw definition)"
|
|
: "";
|
|
throw new HTMLPurifier_Exception(
|
|
"Inconsistent use of optimized and unoptimized raw definition retrievals" . $extra
|
|
);
|
|
}
|
|
}
|
|
// check if definition was in memory
|
|
if ($def) {
|
|
if ($def->setup) {
|
|
// invariant: $optimized === true (checked above)
|
|
return null;
|
|
} else {
|
|
return $def;
|
|
}
|
|
}
|
|
// if optimized, check if definition was in cache
|
|
// (because we do the memory check first, this formulation
|
|
// is prone to cache slamming, but I think
|
|
// guaranteeing that either /all/ of the raw
|
|
// setup code or /none/ of it is run is more important.)
|
|
if ($optimized) {
|
|
// This code path only gets run once; once we put
|
|
// something in $definitions (which is guaranteed by the
|
|
// trailing code), we always short-circuit above.
|
|
$def = $cache->get($this);
|
|
if ($def) {
|
|
// save the full definition for later, but don't
|
|
// return it yet
|
|
$this->definitions[$type] = $def;
|
|
return null;
|
|
}
|
|
}
|
|
// check invariants for creation
|
|
if (!$optimized) {
|
|
if (!is_null($this->get($type . '.DefinitionID'))) {
|
|
if ($this->chatty) {
|
|
$this->triggerError(
|
|
'Due to a documentation error in previous version of HTML Purifier, your ' .
|
|
'definitions are not being cached. If this is OK, you can remove the ' .
|
|
'%$type.DefinitionRev and %$type.DefinitionID declaration. Otherwise, ' .
|
|
'modify your code to use maybeGetRawDefinition, and test if the returned ' .
|
|
'value is null before making any edits (if it is null, that means that a ' .
|
|
'cached version is available, and no raw operations are necessary). See ' .
|
|
'<a href="http://htmlpurifier.org/docs/enduser-customize.html#optimized">' .
|
|
'Customize</a> for more details',
|
|
E_USER_WARNING
|
|
);
|
|
} else {
|
|
$this->triggerError(
|
|
"Useless DefinitionID declaration",
|
|
E_USER_WARNING
|
|
);
|
|
}
|
|
}
|
|
}
|
|
// initialize it
|
|
$def = $this->initDefinition($type);
|
|
$def->optimized = $optimized;
|
|
return $def;
|
|
}
|
|
throw new HTMLPurifier_Exception("The impossible happened!");
|
|
}
|
|
|
|
/**
|
|
* Initialise definition
|
|
*
|
|
* @param string $type What type of definition to create
|
|
*
|
|
* @return HTMLPurifier_CSSDefinition|HTMLPurifier_HTMLDefinition|HTMLPurifier_URIDefinition
|
|
* @throws HTMLPurifier_Exception
|
|
*/
|
|
private function initDefinition($type)
|
|
{
|
|
// quick checks failed, let's create the object
|
|
if ($type == 'HTML') {
|
|
$def = new HTMLPurifier_HTMLDefinition();
|
|
} elseif ($type == 'CSS') {
|
|
$def = new HTMLPurifier_CSSDefinition();
|
|
} elseif ($type == 'URI') {
|
|
$def = new HTMLPurifier_URIDefinition();
|
|
} else {
|
|
throw new HTMLPurifier_Exception(
|
|
"Definition of $type type not supported"
|
|
);
|
|
}
|
|
$this->definitions[$type] = $def;
|
|
return $def;
|
|
}
|
|
|
|
public function maybeGetRawDefinition($name)
|
|
{
|
|
return $this->getDefinition($name, true, true);
|
|
}
|
|
|
|
/**
|
|
* @return HTMLPurifier_HTMLDefinition|null
|
|
*/
|
|
public function maybeGetRawHTMLDefinition()
|
|
{
|
|
return $this->getDefinition('HTML', true, true);
|
|
}
|
|
|
|
/**
|
|
* @return HTMLPurifier_CSSDefinition|null
|
|
*/
|
|
public function maybeGetRawCSSDefinition()
|
|
{
|
|
return $this->getDefinition('CSS', true, true);
|
|
}
|
|
|
|
/**
|
|
* @return HTMLPurifier_URIDefinition|null
|
|
*/
|
|
public function maybeGetRawURIDefinition()
|
|
{
|
|
return $this->getDefinition('URI', true, true);
|
|
}
|
|
|
|
/**
|
|
* Loads configuration values from an array with the following structure:
|
|
* Namespace.Directive => Value
|
|
*
|
|
* @param array $config_array Configuration associative array
|
|
*/
|
|
public function loadArray($config_array)
|
|
{
|
|
if ($this->isFinalized('Cannot load directives after finalization')) {
|
|
return;
|
|
}
|
|
foreach ($config_array as $key => $value) {
|
|
$key = str_replace('_', '.', $key);
|
|
if (strpos($key, '.') !== false) {
|
|
$this->set($key, $value);
|
|
} else {
|
|
$namespace = $key;
|
|
$namespace_values = $value;
|
|
foreach ($namespace_values as $directive => $value2) {
|
|
$this->set($namespace .'.'. $directive, $value2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a list of array(namespace, directive) for all directives
|
|
* that are allowed in a web-form context as per an allowed
|
|
* namespaces/directives list.
|
|
*
|
|
* @param array $allowed List of allowed namespaces/directives
|
|
* @param HTMLPurifier_ConfigSchema $schema Schema to use, if not global copy
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getAllowedDirectivesForForm($allowed, $schema = null)
|
|
{
|
|
if (!$schema) {
|
|
$schema = HTMLPurifier_ConfigSchema::instance();
|
|
}
|
|
if ($allowed !== true) {
|
|
if (is_string($allowed)) {
|
|
$allowed = array($allowed);
|
|
}
|
|
$allowed_ns = array();
|
|
$allowed_directives = array();
|
|
$blacklisted_directives = array();
|
|
foreach ($allowed as $ns_or_directive) {
|
|
if (strpos($ns_or_directive, '.') !== false) {
|
|
// directive
|
|
if ($ns_or_directive[0] == '-') {
|
|
$blacklisted_directives[substr($ns_or_directive, 1)] = true;
|
|
} else {
|
|
$allowed_directives[$ns_or_directive] = true;
|
|
}
|
|
} else {
|
|
// namespace
|
|
$allowed_ns[$ns_or_directive] = true;
|
|
}
|
|
}
|
|
}
|
|
$ret = array();
|
|
foreach ($schema->info as $key => $def) {
|
|
list($ns, $directive) = explode('.', $key, 2);
|
|
if ($allowed !== true) {
|
|
if (isset($blacklisted_directives["$ns.$directive"])) {
|
|
continue;
|
|
}
|
|
if (!isset($allowed_directives["$ns.$directive"]) && !isset($allowed_ns[$ns])) {
|
|
continue;
|
|
}
|
|
}
|
|
if (isset($def->isAlias)) {
|
|
continue;
|
|
}
|
|
if ($directive == 'DefinitionID' || $directive == 'DefinitionRev') {
|
|
continue;
|
|
}
|
|
$ret[] = array($ns, $directive);
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Loads configuration values from $_GET/$_POST that were posted
|
|
* via ConfigForm
|
|
*
|
|
* @param array $array $_GET or $_POST array to import
|
|
* @param string|bool $index Index/name that the config variables are in
|
|
* @param array|bool $allowed List of allowed namespaces/directives
|
|
* @param bool $mq_fix Boolean whether or not to enable magic quotes fix
|
|
* @param HTMLPurifier_ConfigSchema $schema Schema to use, if not global copy
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public static function loadArrayFromForm($array, $index = false, $allowed = true, $mq_fix = true, $schema = null)
|
|
{
|
|
$ret = HTMLPurifier_Config::prepareArrayFromForm($array, $index, $allowed, $mq_fix, $schema);
|
|
$config = HTMLPurifier_Config::create($ret, $schema);
|
|
return $config;
|
|
}
|
|
|
|
/**
|
|
* Merges in configuration values from $_GET/$_POST to object. NOT STATIC.
|
|
*
|
|
* @param array $array $_GET or $_POST array to import
|
|
* @param string|bool $index Index/name that the config variables are in
|
|
* @param array|bool $allowed List of allowed namespaces/directives
|
|
* @param bool $mq_fix Boolean whether or not to enable magic quotes fix
|
|
*/
|
|
public function mergeArrayFromForm($array, $index = false, $allowed = true, $mq_fix = true)
|
|
{
|
|
$ret = HTMLPurifier_Config::prepareArrayFromForm($array, $index, $allowed, $mq_fix, $this->def);
|
|
$this->loadArray($ret);
|
|
}
|
|
|
|
/**
|
|
* Prepares an array from a form into something usable for the more
|
|
* strict parts of HTMLPurifier_Config
|
|
*
|
|
* @param array $array $_GET or $_POST array to import
|
|
* @param string|bool $index Index/name that the config variables are in
|
|
* @param array|bool $allowed List of allowed namespaces/directives
|
|
* @param bool $mq_fix Boolean whether or not to enable magic quotes fix
|
|
* @param HTMLPurifier_ConfigSchema $schema Schema to use, if not global copy
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function prepareArrayFromForm($array, $index = false, $allowed = true, $mq_fix = true, $schema = null)
|
|
{
|
|
if ($index !== false) {
|
|
$array = (isset($array[$index]) && is_array($array[$index])) ? $array[$index] : array();
|
|
}
|
|
$mq = $mq_fix && version_compare(PHP_VERSION, '7.4.0', '<') && function_exists('get_magic_quotes_gpc') && get_magic_quotes_gpc();
|
|
|
|
$allowed = HTMLPurifier_Config::getAllowedDirectivesForForm($allowed, $schema);
|
|
$ret = array();
|
|
foreach ($allowed as $key) {
|
|
list($ns, $directive) = $key;
|
|
$skey = "$ns.$directive";
|
|
if (!empty($array["Null_$skey"])) {
|
|
$ret[$ns][$directive] = null;
|
|
continue;
|
|
}
|
|
if (!isset($array[$skey])) {
|
|
continue;
|
|
}
|
|
$value = $mq ? stripslashes($array[$skey]) : $array[$skey];
|
|
$ret[$ns][$directive] = $value;
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Loads configuration values from an ini file
|
|
*
|
|
* @param string $filename Name of ini file
|
|
*/
|
|
public function loadIni($filename)
|
|
{
|
|
if ($this->isFinalized('Cannot load directives after finalization')) {
|
|
return;
|
|
}
|
|
$array = parse_ini_file($filename, true);
|
|
$this->loadArray($array);
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not the configuration object is finalized.
|
|
*
|
|
* @param string|bool $error String error message, or false for no error
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isFinalized($error = false)
|
|
{
|
|
if ($this->finalized && $error) {
|
|
$this->triggerError($error, E_USER_ERROR);
|
|
}
|
|
return $this->finalized;
|
|
}
|
|
|
|
/**
|
|
* Finalizes configuration only if auto finalize is on and not
|
|
* already finalized
|
|
*/
|
|
public function autoFinalize()
|
|
{
|
|
if ($this->autoFinalize) {
|
|
$this->finalize();
|
|
} else {
|
|
$this->plist->squash(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finalizes a configuration object, prohibiting further change
|
|
*/
|
|
public function finalize()
|
|
{
|
|
$this->finalized = true;
|
|
$this->parser = null;
|
|
}
|
|
|
|
/**
|
|
* Produces a nicely formatted error message by supplying the
|
|
* stack frame information OUTSIDE of HTMLPurifier_Config.
|
|
*
|
|
* @param string $msg An error message
|
|
* @param int $no An error number
|
|
*/
|
|
protected function triggerError($msg, $no)
|
|
{
|
|
// determine previous stack frame
|
|
$extra = '';
|
|
if ($this->chatty) {
|
|
$trace = debug_backtrace();
|
|
// zip(tail(trace), trace) -- but PHP is not Haskell har har
|
|
for ($i = 0, $c = count($trace); $i < $c - 1; $i++) {
|
|
// XXX this is not correct on some versions of HTML Purifier
|
|
if (isset($trace[$i + 1]['class']) && $trace[$i + 1]['class'] === 'HTMLPurifier_Config') {
|
|
continue;
|
|
}
|
|
$frame = $trace[$i];
|
|
$extra = " invoked on line {$frame['line']} in file {$frame['file']}";
|
|
break;
|
|
}
|
|
}
|
|
trigger_error($msg . $extra, $no);
|
|
}
|
|
|
|
/**
|
|
* Returns a serialized form of the configuration object that can
|
|
* be reconstituted.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function serialize()
|
|
{
|
|
$this->getDefinition('HTML');
|
|
$this->getDefinition('CSS');
|
|
$this->getDefinition('URI');
|
|
return serialize($this);
|
|
}
|
|
|
|
}
|
|
|
|
// vim: et sw=4 sts=4
|