f"m3(F$2_ġGZ%&OsPe(e|N٨(5vw,){J| w] 3J(R vѲ?6+; f=Cȯ&Ȟ N+0}`yGOiCƄۡÚYvtL~iINyo_M/G% VO`q46]3?iQ')~tK]lg;2B1ō/U3 D@sVrUrӪl<nx#alJ;}rsPEw? $5y戲ڝ`& vҿ]z6lx[UktW.VS1>(VQIy#@`dJIT_v$>q]G־8<  ꈁnu}[ 9TXYԐ#h=64e,6ƭ΀Nv* %t}/#ɏfJ0Bf.(U?Kd#|%bN€ʑ']AJY04W%_~oq*,ZƐ$ԉkA& mvzUfT_ jɳtSL% aǫWdf$CW*i*@JRPJ.+[}@ݭ[E{nŵЗdKyk*hv(n*&k ^)jCW*zt+Ú ƏˁR6M~7HԪ( cHXo/uMs;P|4̃Y2ya/d 2.n+#ӒC|XU*S}M@u}u|\kWs-bZo@v:˔5z ;2U?^jI8e2|o<`+鋘IuوsDnXyrIhԬ^/DM$VɏfJ0BK=1w ؗj&q* ޲((ft?okx _izNV}1S8}?B@%_҆~h~ 2]Z*S H)k?5WE7T4x"'}Tt,D5H a>nn(EYuُ4s־f9y|`SCbꏑ -#= @!6Szjp7fS3FI`dDŽX5Kܷ?omI|*Ç|i`L% =8H=V,mq-$ׂ|Ex5Gt]8A4$:Q0_ӘH`ۂOn:ru;#88sG UW.N\ĿڏZ0rZÖz?ϐ)fH9)/ߠ*^xງwE6&X2~8#QUو ׿Ǖׂ߫{ԍ%;_ǰ>* $PؗV lV쳧Bүz){NvjYֺQoV^lvOt1y!$zeKde4}9tAq ĥB;-ć0^0 N:eYe{qG#3jg:~K cOUÈ^Q1#܍rU.dg*BT gQvlOE^ ~r*>L(8JC6!u} L# *QR?Ć7ׄt{(S=>.6=}FdW=2[@3!X㷯&_`QX Ĉ 8Q߾{IG/Rso}xg}JZ%k҅9;Kw405zA,]zHcDʓ򽫻)ɿw#9O -Vne$ :aUX죓l]MHb`WB}^z=Z(aU3e27].vr$ziZ+ rz/.OP -FE0+:GdXk N8kMd4H9IOG[}(C| ?=R;6ZyxUp>9qG-o R_Z#sՌߏ*@9D阩F. :lL* !.NSNrPL"bg s)/z#5U:*>M5{9on *ӓlw'）.?>uZ`Er(/LրSX07IIC^];$kƫjI/ D;\܉?5(s<%żvp.2I)ci!)E0kxr;t=T?Ga/f]=G+d0FŻ=3hD|7\A9Pue5#A+@b`P~ud1Cx"+;*iC%Tx3c;q (C<}<1kɵm4:귃 -\E NQ+u݂vvxTAm _DV{8 w8]o2)u2 a$XT/TPȣ[fqO^NS:z-A#`ekr 22D?`BJPT5ͤe6U#_@5N)swc3:)}`,;J[ 34!hE$36# x^PK%yy >Bџ at >;,z˹<;˴F>gZ&sMwTe'T*3_ DNIݶ[8Yvf1/4md,3R@-*|s-v3iZ9AȖ 4f8'Hm/mJ;7lbU.* ѭcOb؝Q~\Avmtor) { $error = $injector->prepare($config, $context); if (!$error) { continue; } array_splice($this->injectors, $ix, 1); // rm the injector trigger_error("Cannot enable {$injector->name} injector because $error is not allowed", E_USER_WARNING); } // -- end INJECTOR -- // a note on reprocessing: // In order to reduce code duplication, whenever some code needs // to make HTML changes in order to make things "correct", the // new HTML gets sent through the purifier, regardless of its // status. This means that if we add a start token, because it // was totally necessary, we don't have to update nesting; we just // punt ($reprocess = true; continue;) and it does that for us. // isset is in loop because $tokens size changes during loop exec for (;; // only increment if we don't need to reprocess $reprocess ? $reprocess = false : $token = $zipper->next($token)) { // check for a rewind if (is_int($i)) { // possibility: disable rewinding if the current token has a // rewind set on it already. This would offer protection from // infinite loop, but might hinder some advanced rewinding. $rewind_offset = $this->injectors[$i]->getRewindOffset(); if (is_int($rewind_offset)) { for ($j = 0; $j < $rewind_offset; $j++) { if (empty($zipper->front)) break; $token = $zipper->prev($token); // indicate that other injectors should not process this token, // but we need to reprocess it. See Note [Injector skips] unset($token->skip[$i]); $token->rewind = $i; if ($token instanceof HTMLPurifier_Token_Start) { array_pop($this->stack); } elseif ($token instanceof HTMLPurifier_Token_End) { $this->stack[] = $token->start; } } } $i = false; } // handle case of document end if ($token === NULL) { // kill processing if stack is empty if (empty($this->stack)) { break; } // peek $top_nesting = array_pop($this->stack); $this->stack[] = $top_nesting; // send error [TagClosedSuppress] if ($e && !isset($top_nesting->armor['MakeWellFormed_TagClosedError'])) { $e->send(E_NOTICE, 'Strategy_MakeWellFormed: Tag closed by document end', $top_nesting); } // append, don't splice, since this is the end $token = new HTMLPurifier_Token_End($top_nesting->name); // punt! $reprocess = true; continue; } //echo '
'; printZipper($zipper, $token);//printTokens($this->stack); //flush(); // quick-check: if it's not a tag, no need to process if (empty($token->is_tag)) { if ($token instanceof HTMLPurifier_Token_Text) { foreach ($this->injectors as $i => $injector) { if (isset($token->skip[$i])) { // See Note [Injector skips] continue; } if ($token->rewind !== null && $token->rewind !== $i) { continue; } // XXX fuckup $r = $token; $injector->handleText($r); $token = $this->processToken($r, $i); $reprocess = true; break; } } // another possibility is a comment continue; } if (isset($definition->info[$token->name])) { $type = $definition->info[$token->name]->child->type; } else { $type = false; // Type is unknown, treat accordingly } // quick tag checks: anything that's *not* an end tag $ok = false; if ($type === 'empty' && $token instanceof HTMLPurifier_Token_Start) { // claims to be a start tag but is empty $token = new HTMLPurifier_Token_Empty( $token->name, $token->attr, $token->line, $token->col, $token->armor ); $ok = true; } elseif ($type && $type !== 'empty' && $token instanceof HTMLPurifier_Token_Empty) { // claims to be empty but really is a start tag // NB: this assignment is required $old_token = $token; $token = new HTMLPurifier_Token_End($token->name); $token = $this->insertBefore( new HTMLPurifier_Token_Start($old_token->name, $old_token->attr, $old_token->line, $old_token->col, $old_token->armor) ); // punt (since we had to modify the input stream in a non-trivial way) $reprocess = true; continue; } elseif ($token instanceof HTMLPurifier_Token_Empty) { // real empty token $ok = true; } elseif ($token instanceof HTMLPurifier_Token_Start) { // start tag // ...unless they also have to close their parent if (!empty($this->stack)) { // Performance note: you might think that it's rather // inefficient, recalculating the autoclose information // for every tag that a token closes (since when we // do an autoclose, we push a new token into the // stream and then /process/ that, before // re-processing this token.) But this is // necessary, because an injector can make an // arbitrary transformations to the autoclosing // tokens we introduce, so things may have changed // in the meantime. Also, doing the inefficient thing is // "easy" to reason about (for certain perverse definitions // of "easy") $parent = array_pop($this->stack); $this->stack[] = $parent; $parent_def = null; $parent_elements = null; $autoclose = false; if (isset($definition->info[$parent->name])) { $parent_def = $definition->info[$parent->name]; $parent_elements = $parent_def->child->getAllowedElements($config); $autoclose = !isset($parent_elements[$token->name]); } if ($autoclose && $definition->info[$token->name]->wrap) { // Check if an element can be wrapped by another // element to make it valid in a context (for // example,
      needs a
    • in between) $wrapname = $definition->info[$token->name]->wrap; $wrapdef = $definition->info[$wrapname]; $elements = $wrapdef->child->getAllowedElements($config); if (isset($elements[$token->name]) && isset($parent_elements[$wrapname])) { $newtoken = new HTMLPurifier_Token_Start($wrapname); $token = $this->insertBefore($newtoken); $reprocess = true; continue; } } $carryover = false; if ($autoclose && $parent_def->formatting) { $carryover = true; } if ($autoclose) { // check if this autoclose is doomed to fail // (this rechecks $parent, which his harmless) $autoclose_ok = isset($global_parent_allowed_elements[$token->name]); if (!$autoclose_ok) { foreach ($this->stack as $ancestor) { $elements = $definition->info[$ancestor->name]->child->getAllowedElements($config); if (isset($elements[$token->name])) { $autoclose_ok = true; break; } if ($definition->info[$token->name]->wrap) { $wrapname = $definition->info[$token->name]->wrap; $wrapdef = $definition->info[$wrapname]; $wrap_elements = $wrapdef->child->getAllowedElements($config); if (isset($wrap_elements[$token->name]) && isset($elements[$wrapname])) { $autoclose_ok = true; break; } } } } if ($autoclose_ok) { // errors need to be updated $new_token = new HTMLPurifier_Token_End($parent->name); $new_token->start = $parent; // [TagClosedSuppress] if ($e && !isset($parent->armor['MakeWellFormed_TagClosedError'])) { if (!$carryover) { $e->send(E_NOTICE, 'Strategy_MakeWellFormed: Tag auto closed', $parent); } else { $e->send(E_NOTICE, 'Strategy_MakeWellFormed: Tag carryover', $parent); } } if ($carryover) { $element = clone $parent; // [TagClosedAuto] $element->armor['MakeWellFormed_TagClosedError'] = true; $element->carryover = true; $token = $this->processToken(array($new_token, $token, $element)); } else { $token = $this->insertBefore($new_token); } } else { $token = $this->remove(); } $reprocess = true; continue; } } $ok = true; } if ($ok) { foreach ($this->injectors as $i => $injector) { if (isset($token->skip[$i])) { // See Note [Injector skips] continue; } if ($token->rewind !== null && $token->rewind !== $i) { continue; } $r = $token; $injector->handleElement($r); $token = $this->processToken($r, $i); $reprocess = true; break; } if (!$reprocess) { // ah, nothing interesting happened; do normal processing if ($token instanceof HTMLPurifier_Token_Start) { $this->stack[] = $token; } elseif ($token instanceof HTMLPurifier_Token_End) { throw new HTMLPurifier_Exception( 'Improper handling of end tag in start code; possible error in MakeWellFormed' ); } } continue; } // sanity check: we should be dealing with a closing tag if (!$token instanceof HTMLPurifier_Token_End) { throw new HTMLPurifier_Exception('Unaccounted for tag token in input stream, bug in HTML Purifier'); } // make sure that we have something open if (empty($this->stack)) { if ($escape_invalid_tags) { if ($e) { $e->send(E_WARNING, 'Strategy_MakeWellFormed: Unnecessary end tag to text'); } $token = new HTMLPurifier_Token_Text($generator->generateFromToken($token)); } else { if ($e) { $e->send(E_WARNING, 'Strategy_MakeWellFormed: Unnecessary end tag removed'); } $token = $this->remove(); } $reprocess = true; continue; } // first, check for the simplest case: everything closes neatly. // Eventually, everything passes through here; if there are problems // we modify the input stream accordingly and then punt, so that // the tokens get processed again. $current_parent = array_pop($this->stack); if ($current_parent->name == $token->name) { $token->start = $current_parent; foreach ($this->injectors as $i => $injector) { if (isset($token->skip[$i])) { // See Note [Injector skips] continue; } if ($token->rewind !== null && $token->rewind !== $i) { continue; } $r = $token; $injector->handleEnd($r); $token = $this->processToken($r, $i); $this->stack[] = $current_parent; $reprocess = true; break; } continue; } // okay, so we're trying to close the wrong tag // undo the pop previous pop $this->stack[] = $current_parent; // scroll back the entire nest, trying to find our tag. // (feature could be to specify how far you'd like to go) $size = count($this->stack); // -2 because -1 is the last element, but we already checked that $skipped_tags = false; for ($j = $size - 2; $j >= 0; $j--) { if ($this->stack[$j]->name == $token->name) { $skipped_tags = array_slice($this->stack, $j); break; } } // we didn't find the tag, so remove if ($skipped_tags === false) { if ($escape_invalid_tags) { if ($e) { $e->send(E_WARNING, 'Strategy_MakeWellFormed: Stray end tag to text'); } $token = new HTMLPurifier_Token_Text($generator->generateFromToken($token)); } else { if ($e) { $e->send(E_WARNING, 'Strategy_MakeWellFormed: Stray end tag removed'); } $token = $this->remove(); } $reprocess = true; continue; } // do errors, in REVERSE $j order: a,b,c with $c = count($skipped_tags); if ($e) { for ($j = $c - 1; $j > 0; $j--) { // notice we exclude $j == 0, i.e. the current ending tag, from // the errors... [TagClosedSuppress] if (!isset($skipped_tags[$j]->armor['MakeWellFormed_TagClosedError'])) { $e->send(E_NOTICE, 'Strategy_MakeWellFormed: Tag closed by element end', $skipped_tags[$j]); } } } // insert tags, in FORWARD $j order: c,b,a with $replace = array($token); for ($j = 1; $j < $c; $j++) { // ...as well as from the insertions $new_token = new HTMLPurifier_Token_End($skipped_tags[$j]->name); $new_token->start = $skipped_tags[$j]; array_unshift($replace, $new_token); if (isset($definition->info[$new_token->name]) && $definition->info[$new_token->name]->formatting) { // [TagClosedAuto] $element = clone $skipped_tags[$j]; $element->carryover = true; $element->armor['MakeWellFormed_TagClosedError'] = true; $replace[] = $element; } } $token = $this->processToken($replace); $reprocess = true; continue; } $context->destroy('CurrentToken'); $context->destroy('CurrentNesting'); $context->destroy('InputZipper'); unset($this->injectors, $this->stack, $this->tokens); return $zipper->toArray($token); } /** * Processes arbitrary token values for complicated substitution patterns. * In general: * * If $token is an array, it is a list of tokens to substitute for the * current token. These tokens then get individually processed. If there * is a leading integer in the list, that integer determines how many * tokens from the stream should be removed. * * If $token is a regular token, it is swapped with the current token. * * If $token is false, the current token is deleted. * * If $token is an integer, that number of tokens (with the first token * being the current one) will be deleted. * * @param HTMLPurifier_Token|array|int|bool $token Token substitution value * @param HTMLPurifier_Injector|int $injector Injector that performed the substitution; default is if * this is not an injector related operation. * @throws HTMLPurifier_Exception */ protected function processToken($token, $injector = -1) { // Zend OpCache miscompiles $token = array($token), so // avoid this pattern. See: https://github.com/ezyang/htmlpurifier/issues/108 // normalize forms of token if (is_object($token)) { $tmp = $token; $token = array(1, $tmp); } if (is_int($token)) { $tmp = $token; $token = array($tmp); } if ($token === false) { $token = array(1); } if (!is_array($token)) { throw new HTMLPurifier_Exception('Invalid token type from injector'); } if (!is_int($token[0])) { array_unshift($token, 1); } if ($token[0] === 0) { throw new HTMLPurifier_Exception('Deleting zero tokens is not valid'); } // $token is now an array with the following form: // array(number nodes to delete, new node 1, new node 2, ...) $delete = array_shift($token); list($old, $r) = $this->zipper->splice($this->token, $delete, $token); if ($injector > -1) { // See Note [Injector skips] // Determine appropriate skips. Here's what the code does: // *If* we deleted one or more tokens, copy the skips // of those tokens into the skips of the new tokens (in $token). // Also, mark the newly inserted tokens as having come from // $injector. $oldskip = isset($old[0]) ? $old[0]->skip : array(); foreach ($token as $object) { $object->skip = $oldskip; $object->skip[$injector] = true; } } return $r; } /** * Inserts a token before the current token. Cursor now points to * this token. You must reprocess after this. * @param HTMLPurifier_Token $token */ private function insertBefore($token) { // NB not $this->zipper->insertBefore(), due to positioning // differences $splice = $this->zipper->splice($this->token, 0, array($token)); return $splice[1]; } /** * Removes current token. Cursor now points to new token occupying previously * occupied space. You must reprocess after this. */ private function remove() { return $this->zipper->delete(); } } // Note [Injector skips] // ~~~~~~~~~~~~~~~~~~~~~ // When I originally designed this class, the idea behind the 'skip' // property of HTMLPurifier_Token was to help avoid infinite loops // in injector processing. For example, suppose you wrote an injector // that bolded swear words. Naively, you might write it so that // whenever you saw ****, you replaced it with ****. // // When this happens, we will reprocess all of the tokens with the // other injectors. Now there is an opportunity for infinite loop: // if we rerun the swear-word injector on these tokens, we might // see **** and then reprocess again to get // **** ad infinitum. // // Thus, the idea of a skip is that once we process a token with // an injector, we mark all of those tokens as having "come from" // the injector, and we never run the injector again on these // tokens. // // There were two more complications, however: // // - With HTMLPurifier_Injector_RemoveEmpty, we noticed that if // you had , after you removed the , you // really would like this injector to go back and reprocess // the tag, discovering that it is now empty and can be // removed. So we reintroduced the possibility of infinite looping // by adding a "rewind" function, which let you go back to an // earlier point in the token stream and reprocess it with injectors. // Needless to say, we need to UN-skip the token so it gets // reprocessed. // // - Suppose that you successfuly process a token, replace it with // one with your skip mark, but now another injector wants to // process the skipped token with another token. Should you continue // to skip that new token, or reprocess it? If you reprocess, // you can end up with an infinite loop where one injector converts // to , and then another injector converts it back. So // we inherit the skips, but for some reason, I thought that we // should inherit the skip from the first token of the token // that we deleted. Why? Well, it seems to work OK. // // If I were to redesign this functionality, I would absolutely not // go about doing it this way: the semantics are just not very well // defined, and in any case you probably wanted to operate on trees, // not token streams. // vim: et sw=4 sts=4