vendor/uvdesk/core-framework/Utils/HTMLFilter.php line 351

Open in your IDE?
  1. <?php
  2. /**
  3.  * htmlfilter.inc
  4.  * ---------------
  5.  * This set of functions allows you to filter html in order to remove
  6.  * any malicious tags from it. Useful in cases when you need to filter
  7.  * user input for any cross-site-scripting attempts.
  8.  *
  9.  * Copyright (C) 2002-2004 by Duke University
  10.  *
  11.  * This library is free software; you can redistribute it and/or
  12.  * modify it under the terms of the GNU Lesser General Public
  13.  * License as published by the Free Software Foundation; either
  14.  * version 2.1 of the License, or (at your option) any later version.
  15.  *
  16.  * This library is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
  19.  * Lesser General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU Lesser General Public
  22.  * License along with this library; if not, write to the Free Software
  23.  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  24.  * 02110-1301  USA
  25.  *
  26.  * @Author    Konstantin Riabitsev <icon@linux.duke.edu>
  27.  * @Author  Jim Jagielski <jim@jaguNET.com / jimjag@gmail.com>
  28.  */
  30. namespace Webkul\UVDesk\CoreFrameworkBundle\Utils;
  32. use Symfony\Component\DomCrawler\Crawler;
  34. class HTMLFilter
  35. {
  36.     /**
  37.      * This function returns the final tag out of the tag name, an array
  38.      * of attributes, and the type of the tag. This function is called by
  39.      * tln_sanitize internally.
  40.      *
  41.      * @param string $tagname the name of the tag.
  42.      * @param array $attary the array of attributes and their values
  43.      * @param integer $tagtype The type of the tag (see in comments).
  44.      * @return string A string with the final tag representation.
  45.      */
  46.     public function tln_tagprint($tagname, $attary, $tagtype) {
  47.         if ($tagtype == 2) {
  48.             $fulltag = '</' . $tagname . '>';
  49.         } else {
  50.             $fulltag = '<' . $tagname;
  51.             if (is_array($attary) && sizeof($attary)) {
  52.                 $atts = array();
  53.                 while (list($attname, $attvalue) = each($attary)) {
  54.                     array_push($atts, "$attname=$attvalue");
  55.                 }
  56.                 $fulltag .= ' ' . join(' ', $atts);
  57.             }
  58.             if ($tagtype == 3) {
  59.                 $fulltag .= ' /';
  60.             }
  61.             $fulltag .= '>';
  62.         }
  63.         return $fulltag;
  64.     }
  66.     /**
  67.      * A small helper function to use with array_walk. Modifies a by-ref
  68.      * value and makes it lowercase.
  69.      *
  70.      * @param string $val a value passed by-ref.
  71.      * @return        void since it modifies a by-ref value.
  72.      */
  73.     public function tln_casenormalize(&$val) {
  74.         $val = strtolower($val);
  75.     }
  77.     /**
  78.      * This function skips any whitespace from the current position within
  79.      * a string and to the next non-whitespace value.
  80.      *
  81.      * @param string $body the string
  82.      * @param integer $offset the offset within the string where we should start
  83.      *                   looking for the next non-whitespace character.
  84.      * @return integer          the location within the $body where the next
  85.      *                   non-whitespace char is located.
  86.      */
  87.     public function tln_skipspace($body, $offset) {
  88.         preg_match('/^(\s*)/s', substr($body, $offset), $matches);
  89.         if (isset($matches[1]) && is_array($matches[1]) && sizeof($matches[1])) {
  90.             $count = strlen($matches[1]);
  91.             $offset += $count;
  92.         }
  93.         return $offset;
  94.     }
  96.     /**
  97.      * This function looks for the next character within a string.    It's
  98.      * really just a glorified "strpos", except it catches the failures
  99.      * nicely.
  100.      *
  101.      * @param string $body   The string to look for needle in.
  102.      * @param integer $offset Start looking from this position.
  103.      * @param string $needle The character/string to look for.
  104.      * @return integer           location of the next occurrence of the needle, or
  105.      *                   strlen($body) if needle wasn't found.
  106.      */
  107.     public function tln_findnxstr($body, $offset, $needle) {
  108.         $pos = strpos($body, $needle, $offset);
  109.         if ($pos === false) {
  110.             $pos = strlen($body);
  111.         }
  112.         return $pos;
  113.     }
  115.     /**
  116.      * This function takes a PCRE-style regexp and tries to match it
  117.      * within the string.
  118.      *
  119.      * @param string $body   The string to look for needle in.
  120.      * @param integer $offset Start looking from here.
  121.      * @param string $reg       A PCRE-style regex to match.
  122.      * @return array|boolean  Returns a false if no matches found, or an array
  123.      *                   with the following members:
  124.      *                   - integer with the location of the match within $body
  125.      *                   - string with whatever content between offset and the match
  126.      *                   - string with whatever it is we matched
  127.      */
  128.     public function tln_findnxreg($body, $offset, $reg) {
  129.         $matches = array();
  130.         $retarr = array();
  131.         $preg_rule = '%^(.*?)(' . $reg . ')%s';
  132.         preg_match($preg_rule, substr($body, $offset), $matches);
  133.         if (!isset($matches[0])) {
  134.             $retarr = false;
  135.         } else {
  136.             $retarr[0] = $offset + strlen($matches[1]);
  137.             $retarr[1] = $matches[1];
  138.             $retarr[2] = $matches[2];
  139.         }
  140.         return $retarr;
  141.     }
  143.     /**
  144.      * This function looks for the next tag.
  145.      *
  146.      * @param string $body   String where to look for the next tag.
  147.      * @param integer $offset Start looking from here.
  148.      * @return array|boolean false if no more tags exist in the body, or
  149.      *                   an array with the following members:
  150.      *                   - string with the name of the tag
  151.      *                   - array with attributes and their values
  152.      *                   - integer with tag type (1, 2, or 3)
  153.      *                   - integer where the tag starts (starting "<")
  154.      *                   - integer where the tag ends (ending ">")
  155.      *                   first three members will be false, if the tag is invalid.
  156.      */
  157.     public function tln_getnxtag($body, $offset) {
  158.         if ($offset > strlen($body)) {
  159.             return false;
  160.         }
  161.         $lt = $this->tln_findnxstr($body, $offset, '<');
  162.         if ($lt == strlen($body)) {
  163.             return false;
  164.         }
  165.         /**
  166.          * We are here:
  167.          * blah blah <tag attribute="value">
  168.          * \---------^
  169.          */
  170.         $pos = $this->tln_skipspace($body, $lt + 1);
  171.         if ($pos >= strlen($body)) {
  172.             return array(false, false, false, $lt, strlen($body));
  173.         }
  174.         /**
  175.          * There are 3 kinds of tags:
  176.          * 1. Opening tag, e.g.:
  177.          *      <a href="blah">
  178.          * 2. Closing tag, e.g.:
  179.          *      </a>
  180.          * 3. XHTML-style content-less tag, e.g.:
  181.          *      <img src="blah"/>
  182.          */
  183.         switch (substr($body, $pos, 1)) {
  184.             case '/':
  185.                 $tagtype = 2;
  186.                 $pos++;
  187.                 break;
  188.             case '!':
  189.                 /**
  190.                  * A comment or an SGML declaration.
  191.                  */
  192.                 if (substr($body, $pos + 1, 2) == '--') {
  193.                     $gt = strpos($body, '-->', $pos);
  194.                     if ($gt === false) {
  195.                         $gt = strlen($body);
  196.                     } else {
  197.                         $gt += 2;
  198.                     }
  199.                     return array(false, false, false, $lt, $gt);
  200.                 } else {
  201.                     $gt = $this->tln_findnxstr($body, $pos, '>');
  202.                     return array(false, false, false, $lt, $gt);
  203.                 }
  204.                 break;
  205.             default:
  206.                 /**
  207.                  * Assume tagtype 1 for now. If it's type 3, we'll switch values
  208.                  * later.
  209.                  */
  210.                 $tagtype = 1;
  211.                 break;
  212.         }
  214.         /**
  215.          * Look for next [\W-_], which will indicate the end of the tag name.
  216.          */
  217.         $regary = $this->tln_findnxreg($body, $pos, '[^\w\-_]');
  218.         if ($regary == false) {
  219.             return array(false, false, false, $lt, strlen($body));
  220.         }
  221.         list($pos, $tagname, $match) = $regary;
  222.         $tagname = strtolower($tagname);
  224.         /**
  225.          * $match can be either of these:
  226.          * '>'    indicating the end of the tag entirely.
  227.          * '\s' indicating the end of the tag name.
  228.          * '/'    indicating that this is type-3 xhtml tag.
  229.          *
  230.          * Whatever else we find there indicates an invalid tag.
  231.          */
  232.         switch ($match) {
  233.             case '/':
  234.                 /**
  235.                  * This is an xhtml-style tag with a closing / at the
  236.                  * end, like so: <img src="blah"/>. Check if it's followed
  237.                  * by the closing bracket. If not, then this tag is invalid
  238.                  */
  239.                 if (substr($body, $pos, 2) == '/>') {
  240.                     $pos++;
  241.                     $tagtype = 3;
  242.                 } else {
  243.                     $gt = $this->tln_findnxstr($body, $pos, '>');
  244.                     $retary = array(false, false, false, $lt, $gt);
  245.                     return $retary;
  246.                 }
  247.                 //intentional fall-through
  248.             case '>':
  249.                 return array($tagname, false, $tagtype, $lt, $pos);
  250.                 break;
  251.             default:
  252.                 /**
  253.                  * Check if it's whitespace
  254.                  */
  255.                 if (preg_match('/\s/', $match)) {
  256.                 } else {
  257.                     /**
  258.                      * This is an invalid tag! Look for the next closing ">".
  259.                      */
  260.                     $gt = $this->tln_findnxstr($body, $lt, '>');
  261.                     return array(false, false, false, $lt, $gt);
  262.                 }
  263.         }
  265.         /**
  266.          * At this point we're here:
  267.          * <tagname     attribute='blah'>
  268.          * \-------^
  269.          *
  270.          * At this point we loop in order to find all attributes.
  271.          */
  272.         $attary = array();
  274.         while ($pos <= strlen($body)) {
  275.             $pos = $this->tln_skipspace($body, $pos);
  276.             if ($pos == strlen($body)) {
  277.                 /**
  278.                  * Non-closed tag.
  279.                  */
  280.                 return array(false, false, false, $lt, $pos);
  281.             }
  282.             /**
  283.              * See if we arrived at a ">" or "/>", which means that we reached
  284.              * the end of the tag.
  285.              */
  286.             $matches = array();
  287.             preg_match('%^(\s*)(>|/>)%s', substr($body, $pos), $matches);
  288.             if (isset($matches[0]) && $matches[0]) {
  289.                 /**
  290.                  * Yep. So we did.
  291.                  */
  292.                 $pos += strlen($matches[1]);
  293.                 if ($matches[2] == '/>') {
  294.                     $tagtype = 3;
  295.                     $pos++;
  296.                 }
  297.                 return array($tagname, $attary, $tagtype, $lt, $pos);
  298.             }
  300.             /**
  301.              * There are several types of attributes, with optional
  302.              * [:space:] between members.
  303.              * Type 1:
  304.              *     attrname[:space:]=[:space:]'CDATA'
  305.              * Type 2:
  306.              *     attrname[:space:]=[:space:]"CDATA"
  307.              * Type 3:
  308.              *     attr[:space:]=[:space:]CDATA
  309.              * Type 4:
  310.              *     attrname
  311.              *
  312.              * We leave types 1 and 2 the same, type 3 we check for
  313.              * '"' and convert to "&quot" if needed, then wrap in
  314.              * double quotes. Type 4 we convert into:
  315.              * attrname="yes".
  316.              */
  317.             $regary = $this->tln_findnxreg($body, $pos, '[^\w\-_]');
  318.             if ($regary == false) {
  319.                 /**
  320.                  * Looks like body ended before the end of tag.
  321.                  */
  322.                 return array(false, false, false, $lt, strlen($body));
  323.             }
  324.             list($pos, $attname, $match) = $regary;
  325.             $attname = strtolower($attname);
  326.             /**
  327.              * We arrived at the end of attribute name. Several things possible
  328.              * here:
  329.              * '>'    means the end of the tag and this is attribute type 4
  330.              * '/'    if followed by '>' means the same thing as above
  331.              * '\s' means a lot of things -- look what it's followed by.
  332.              *        anything else means the attribute is invalid.
  333.              */
  334.             switch ($match) {
  335.                 case '/':
  336.                     /**
  337.                      * This is an xhtml-style tag with a closing / at the
  338.                      * end, like so: <img src="blah"/>. Check if it's followed
  339.                      * by the closing bracket. If not, then this tag is invalid
  340.                      */
  341.                     if (substr($body, $pos, 2) == '/>') {
  342.                         $pos++;
  343.                         $tagtype = 3;
  344.                     } else {
  345.                         $gt = $this->tln_findnxstr($body, $pos, '>');
  346.                         $retary = array(false, false, false, $lt, $gt);
  347.                         return $retary;
  348.                     }
  349.                     //intentional fall-through
  350.                 case '>':
  351.                     $attary{$attname} = '"yes"';
  352.                     return array($tagname, $attary, $tagtype, $lt, $pos);
  353.                     break;
  354.                 default:
  355.                     /**
  356.                      * Skip whitespace and see what we arrive at.
  357.                      */
  358.                     $pos = $this->tln_skipspace($body, $pos);
  359.                     $char = substr($body, $pos, 1);
  360.                     /**
  361.                      * Two things are valid here:
  362.                      * '=' means this is attribute type 1 2 or 3.
  363.                      * \w means this was attribute type 4.
  364.                      * anything else we ignore and re-loop. End of tag and
  365.                      * invalid stuff will be caught by our checks at the beginning
  366.                      * of the loop.
  367.                      */
  368.                     if ($char == '=') {
  369.                         $pos++;
  370.                         $pos = $this->tln_skipspace($body, $pos);
  371.                         /**
  372.                          * Here are 3 possibilities:
  373.                          * "'"    attribute type 1
  374.                          * '"'    attribute type 2
  375.                          * everything else is the content of tag type 3
  376.                          */
  377.                         $quot = substr($body, $pos, 1);
  378.                         if ($quot == '\'') {
  379.                             $regary = $this->tln_findnxreg($body, $pos + 1, '\'');
  380.                             if ($regary == false) {
  381.                                 return array(false, false, false, $lt, strlen($body));
  382.                             }
  383.                             list($pos, $attval, $match) = $regary;
  384.                             $pos++;
  385.                             $attary{$attname} = '\'' . $attval . '\'';
  386.                         } else {
  387.                             if ($quot == '"') {
  388.                                 $regary = $this->tln_findnxreg($body, $pos + 1, '\"');
  389.                                 if ($regary == false) {
  390.                                     return array(false, false, false, $lt, strlen($body));
  391.                                 }
  392.                                 list($pos, $attval, $match) = $regary;
  393.                                 $pos++;
  394.                                 $attary{$attname} = '"' . $attval . '"';
  395.                             } else {
  396.                                 /**
  397.                                  * These are hateful. Look for \s, or >.
  398.                                  */
  399.                                 $regary = $this->tln_findnxreg($body, $pos, '[\s>]');
  400.                                 if ($regary == false) {
  401.                                     return array(false, false, false, $lt, strlen($body));
  402.                                 }
  403.                                 list($pos, $attval, $match) = $regary;
  404.                                 /**
  405.                                  * If it's ">" it will be caught at the top.
  406.                                  */
  407.                                 $attval = preg_replace('/\"/s', '&quot;', $attval);
  408.                                 $attary{$attname} = '"' . $attval . '"';
  409.                             }
  410.                         }
  411.                     } else {
  412.                         if (preg_match('|[\w/>]|', $char)) {
  413.                             /**
  414.                              * That was attribute type 4.
  415.                              */
  416.                             $attary{$attname} = '"yes"';
  417.                         } else {
  418.                             /**
  419.                              * An illegal character. Find next '>' and return.
  420.                              */
  421.                             $gt = $this->tln_findnxstr($body, $pos, '>');
  422.                             return array(false, false, false, $lt, $gt);
  423.                         }
  424.                     }
  425.             }
  426.         }
  427.         /**
  428.          * The fact that we got here indicates that the tag end was never
  429.          * found. Return invalid tag indication so it gets stripped.
  430.          */
  431.         return array(false, false, false, $lt, strlen($body));
  432.     }
  434.     /**
  435.      * Translates entities into literal values so they can be checked.
  436.      *
  437.      * @param string $attvalue the by-ref value to check.
  438.      * @param string $regex    the regular expression to check against.
  439.      * @param boolean $hex        whether the entites are hexadecimal.
  440.      * @return boolean            True or False depending on whether there were matches.
  441.      */
  442.     public function tln_deent(&$attvalue, $regex, $hex = false) {
  443.         preg_match_all($regex, $attvalue, $matches);
  444.         if (is_array($matches) && sizeof($matches[0]) > 0) {
  445.             $repl = array();
  446.             for ($i = 0; $i < sizeof($matches[0]); $i++) {
  447.                 $numval = $matches[1][$i];
  448.                 if ($hex) {
  449.                     $numval = hexdec($numval);
  450.                 }
  451.                 $repl{$matches[0][$i]} = chr($numval);
  452.             }
  453.             $attvalue = strtr($attvalue, $repl);
  454.             return true;
  455.         } else {
  456.             return false;
  457.         }
  458.     }
  460.     /**
  461.      * This function checks attribute values for entity-encoded values
  462.      * and returns them translated into 8-bit strings so we can run
  463.      * checks on them.
  464.      *
  465.      * @param string $attvalue A string to run entity check against.
  466.      * @return             Void, modifies a reference value.
  467.      */
  468.     public function tln_defang(&$attvalue) {
  469.         /**
  470.          * Skip this if there aren't ampersands or backslashes.
  471.          */
  472.         if (strpos($attvalue, '&') === false
  473.             && strpos($attvalue, '\\') === false
  474.         ) {
  475.             return;
  476.         }
  477.         do {
  478.             $m = false;
  479.             $m = $m || $this->tln_deent($attvalue, '/\&#0*(\d+);*/s');
  480.             $m = $m || $this->tln_deent($attvalue, '/\&#x0*((\d|[a-f])+);*/si', true);
  481.             $m = $m || $this->tln_deent($attvalue, '/\\\\(\d+)/s', true);
  482.         } while ($m == true);
  483.         $attvalue = stripslashes($attvalue);
  484.     }
  486.     /**
  487.      * Kill any tabs, newlines, or carriage returns. Our friends the
  488.      * makers of the browser with 95% market value decided that it'd
  489.      * be funny to make "java[tab]script" be just as good as "javascript".
  490.      *
  491.      * @param string $attvalue     The attribute value before extraneous spaces removed.
  492.      * @return     Void, modifies a reference value.
  493.      */
  494.     public function tln_unspace(&$attvalue) {
  495.         if (strcspn($attvalue, "\t\r\n\0 ") != strlen($attvalue)) {
  496.             $attvalue = str_replace(
  497.                 array("\t", "\r", "\n", "\0", " "),
  498.                 array('', '', '', '', ''),
  499.                 $attvalue
  500.             );
  501.         }
  502.     }
  504.     /**
  505.      * This function runs various checks against the attributes.
  506.      *
  507.      * @param string $tagname            String with the name of the tag.
  508.      * @param array $attary            Array with all tag attributes.
  509.      * @param array $rm_attnames        See description for tln_sanitize
  510.      * @param array $bad_attvals        See description for tln_sanitize
  511.      * @param array $add_attr_to_tag See description for tln_sanitize
  512.      * @return                    Array with modified attributes.
  513.      */
  514.     public function tln_fixatts(
  515.         $tagname,
  516.         $attary,
  517.         $rm_attnames,
  518.         $bad_attvals,
  519.         $add_attr_to_tag
  520.     ) {
  521.         while (list($attname, $attvalue) = each($attary)) {
  522.             /**
  523.              * See if this attribute should be removed.
  524.              */
  525.             foreach ($rm_attnames as $matchtag => $matchattrs) {
  526.                 if (preg_match($matchtag, $tagname)) {
  527.                     foreach ($matchattrs as $matchattr) {
  528.                         if (preg_match($matchattr, $attname)) {
  529.                             unset($attary{$attname});
  530.                             continue;
  531.                         }
  532.                     }
  533.                 }
  534.             }
  535.             /**
  536.              * Remove any backslashes, entities, or extraneous whitespace.
  537.              */
  538.             $this->tln_defang($attvalue);
  539.             $this->tln_unspace($attvalue);
  541.             /**
  542.              * Now let's run checks on the attvalues.
  543.              * I don't expect anyone to comprehend this. If you do,
  544.              * get in touch with me so I can drive to where you live and
  545.              * shake your hand personally. :)
  546.              */
  547.             foreach ($bad_attvals as $matchtag => $matchattrs) {
  548.                 if (preg_match($matchtag, $tagname)) {
  549.                     foreach ($matchattrs as $matchattr => $valary) {
  550.                         if (preg_match($matchattr, $attname)) {
  551.                             /**
  552.                              * There are two arrays in valary.
  553.                              * First is matches.
  554.                              * Second one is replacements
  555.                              */
  556.                             list($valmatch, $valrepl) = $valary;
  557.                             $newvalue = preg_replace($valmatch, $valrepl, $attvalue);
  558.                             if ($newvalue != $attvalue) {
  559.                                 $attary{$attname} = $newvalue;
  560.                             }
  561.                         }
  562.                     }
  563.                 }
  564.             }
  565.         }
  566.         /**
  567.          * See if we need to append any attributes to this tag.
  568.          */
  569.         foreach ($add_attr_to_tag as $matchtag => $addattary) {
  570.             if (preg_match($matchtag, $tagname)) {
  571.                 $attary = array_merge($attary, $addattary);
  572.             }
  573.         }
  574.         return $attary;
  575.     }
  577.     /**
  578.      *
  579.      * @param string $body                    The HTML you wish to filter
  580.      * @param array $tag_list                see description above
  581.      * @param array $rm_tags_with_content see description above
  582.      * @param array $self_closing_tags    see description above
  583.      * @param boolean $force_tag_closing    see description above
  584.      * @param array $rm_attnames            see description above
  585.      * @param array $bad_attvals            see description above
  586.      * @param array $add_attr_to_tag        see description above
  587.      * @return string                       Sanitized html safe to show on your pages.
  588.      */
  589.     public function tln_sanitize(
  590.         $body,
  591.         $tag_list,
  592.         $rm_tags_with_content,
  593.         $self_closing_tags,
  594.         $force_tag_closing,
  595.         $rm_attnames,
  596.         $bad_attvals,
  597.         $add_attr_to_tag
  598.     ) {
  599.         /**
  600.          * Normalize rm_tags and rm_tags_with_content.
  601.          */
  602.         $rm_tags = array_shift($tag_list);
  603.         @array_walk($tag_list, [$this, 'tln_casenormalize']);
  604.         @array_walk($rm_tags_with_content, [$this, 'tln_casenormalize']);
  605.         @array_walk($self_closing_tags, [$this, 'tln_casenormalize']);
  606.         /**
  607.          * See if tag_list is of tags to remove or tags to allow.
  608.          * false  means remove these tags
  609.          * true      means allow these tags
  610.          */
  611.         $curpos = 0;
  612.         $open_tags = array();
  613.         $trusted = "<!-- begin tln_sanitized html -->\n";
  614.         $skip_content = false;
  615.         /**
  616.          * Take care of netscape's stupid javascript entities like
  617.          * &{alert('boo')};
  618.          */
  619.         $body = preg_replace('/&(\{.*?\};)/si', '&amp;\\1', $body);
  620.         while (($curtag = $this->tln_getnxtag($body, $curpos)) != false) {
  621.             list($tagname, $attary, $tagtype, $lt, $gt) = $curtag;
  622.             $free_content = substr($body, $curpos, $lt - $curpos);
  623.             if ($skip_content == false) {
  624.                 $trusted .= $free_content;
  625.             } else {
  626.             }
  627.             if ($tagname != false) {
  628.                 if ($tagtype == 2) {
  629.                     if ($skip_content == $tagname) {
  630.                         /**
  631.                          * Got to the end of tag we needed to remove.
  632.                          */
  633.                         $tagname = false;
  634.                         $skip_content = false;
  635.                     } else {
  636.                         if ($skip_content == false) {
  637.                             if (isset($open_tags{$tagname}) &&
  638.                                 $open_tags{$tagname} > 0
  639.                             ) {
  640.                                 $open_tags{$tagname}--;
  641.                             } else {
  642.                                 $tagname = false;
  643.                             }
  644.                         } else {
  645.                         }
  646.                     }
  647.                 } else {
  648.                     /**
  649.                      * $rm_tags_with_content
  650.                      */
  651.                     if ($skip_content == false) {
  652.                         /**
  653.                          * See if this is a self-closing type and change
  654.                          * tagtype appropriately.
  655.                          */
  656.                         if ($tagtype == 1
  657.                             && in_array($tagname, $self_closing_tags)
  658.                         ) {
  659.                             $tagtype = 3;
  660.                         }
  661.                         /**
  662.                          * See if we should skip this tag and any content
  663.                          * inside it.
  664.                          */
  665.                         if ($tagtype == 1
  666.                             && in_array($tagname, $rm_tags_with_content)
  667.                         ) {
  668.                             $skip_content = $tagname;
  669.                         } else {
  670.                             if (($rm_tags == false
  671.                                     && in_array($tagname, $tag_list)) ||
  672.                                 ($rm_tags == true
  673.                                     && !in_array($tagname, $tag_list))
  674.                             ) {
  675.                                 $tagname = false;
  676.                             } else {
  677.                                 if ($tagtype == 1) {
  678.                                     if (isset($open_tags{$tagname})) {
  679.                                         $open_tags{$tagname}++;
  680.                                     } else {
  681.                                         $open_tags{$tagname} = 1;
  682.                                     }
  683.                                 }
  684.                                 /**
  685.                                  * This is where we run other checks.
  686.                                  */
  687.                                 if (is_array($attary) && sizeof($attary) > 0) {
  688.                                     $attary = $this->tln_fixatts(
  689.                                         $tagname,
  690.                                         $attary,
  691.                                         $rm_attnames,
  692.                                         $bad_attvals,
  693.                                         $add_attr_to_tag
  694.                                     );
  695.                                 }
  696.                             }
  697.                         }
  698.                     } else {
  699.                     }
  700.                 }
  701.                 if ($tagname != false && $skip_content == false) {
  702.                     $trusted .= $this->tln_tagprint($tagname, $attary, $tagtype);
  703.                 }
  704.             } else {
  705.             }
  706.             $curpos = $gt + 1;
  707.         }
  708.         $trusted .= substr($body, $curpos, strlen($body) - $curpos);
  709.         if ($force_tag_closing == true) {
  710.             foreach ($open_tags as $tagname => $opentimes) {
  711.                 while ($opentimes > 0) {
  712.                     $trusted .= '</' . $tagname . '>';
  713.                     $opentimes--;
  714.                 }
  715.             }
  716.             $trusted .= "\n";
  717.         }
  718.         $trusted .= "<!-- end tln_sanitized html -->\n";
  719.         return $trusted;
  720.     }
  722.     // 
  723.     // Use the nifty htmlfilter library
  724.     //
  725.     public function HTMLFilter($body, $trans_image_path, $block_external_images = false) {
  727.         $tag_list = array(
  728.             false,
  729.             "object",
  730.             "meta",
  731.             "html",
  732.             "head",
  733.             "base",
  734.             "link",
  735.             "frame",
  736.             "iframe",
  737.             "plaintext",
  738.             "marquee"
  739.         );
  741.         $rm_tags_with_content = array(
  742.             "script",
  743.             "applet",
  744.             "embed",
  745.             "title",
  746.             "frameset",
  747.             "xmp",
  748.             "xml"
  749.         );
  751.         $self_closing_tags = array(
  752.             "img",
  753.             "br",
  754.             "hr",
  755.             "input",
  756.             "outbind"
  757.         );
  759.         $force_tag_closing = true;
  761.         $rm_attnames = array(
  762.             "/.*/" =>
  763.                 array(
  764.                     // "/target/i",
  765.                     "/^on.*/i",
  766.                     "/^dynsrc/i",
  767.                     "/^data.*/i",
  768.                     "/^lowsrc.*/i"
  769.                 )
  770.         );
  772.         $bad_attvals = array(
  773.             "/.*/" =>
  774.                 array(
  775.                     "/^src|background/i" =>
  776.                         array(
  777.                             array(
  778.                                 '/^([\'"])\s*\S+script\s*:.*([\'"])/si',
  779.                                 '/^([\'"])\s*mocha\s*:*.*([\'"])/si',
  780.                                 '/^([\'"])\s*about\s*:.*([\'"])/si'
  781.                             ),
  782.                             array(
  783.                                 "\\1$trans_image_path\\2",
  784.                                 "\\1$trans_image_path\\2",
  785.                                 "\\1$trans_image_path\\2",
  786.                                 "\\1$trans_image_path\\2"
  787.                             )
  788.                         ),
  789.                     "/^href|action/i" =>
  790.                         array(
  791.                             array(
  792.                                 '/^([\'"])\s*\S+script\s*:.*([\'"])/si',
  793.                                 '/^([\'"])\s*mocha\s*:*.*([\'"])/si',
  794.                                 '/^([\'"])\s*about\s*:.*([\'"])/si'
  795.                             ),
  796.                             array(
  797.                                 "\\1#\\1",
  798.                                 "\\1#\\1",
  799.                                 "\\1#\\1",
  800.                                 "\\1#\\1"
  801.                             )
  802.                         ),
  803.                     "/^style/i" =>
  804.                         array(
  805.                             array(
  806.                                 "/expression/i",
  807.                                 "/binding/i",
  808.                                 "/behaviou*r/i",
  809.                                 "/include-source/i",
  810.                                 '/position\s*:\s*absolute/i',
  811.                                 '/url\s*\(\s*([\'"])\s*\S+script\s*:.*([\'"])\s*\)/si',
  812.                                 '/url\s*\(\s*([\'"])\s*mocha\s*:.*([\'"])\s*\)/si',
  813.                                 '/url\s*\(\s*([\'"])\s*about\s*:.*([\'"])\s*\)/si',
  814.                                 '/(.*)\s*:\s*url\s*\(\s*([\'"]*)\s*\S+script\s*:.*([\'"]*)\s*\)/si'
  815.                             ),
  816.                             array(
  817.                                 "idiocy",
  818.                                 "idiocy",
  819.                                 "idiocy",
  820.                                 "idiocy",
  821.                                 "",
  822.                                 "url(\\1#\\1)",
  823.                                 "url(\\1#\\1)",
  824.                                 "url(\\1#\\1)",
  825.                                 "url(\\1#\\1)",
  826.                                 "url(\\1#\\1)",
  827.                                 "\\1:url(\\2#\\3)"
  828.                             )
  829.                         )
  830.                 )
  831.         );
  833.         if ($block_external_images) {
  834.             array_push(
  835.                 $bad_attvals{'/.*/'}{'/^src|background/i'}[0],
  836.                 '/^([\'\"])\s*https*:.*([\'\"])/si'
  837.             );
  838.             array_push(
  839.                 $bad_attvals{'/.*/'}{'/^src|background/i'}[1],
  840.                 "\\1$trans_image_path\\1"
  841.             );
  842.             array_push(
  843.                 $bad_attvals{'/.*/'}{'/^style/i'}[0],
  844.                 '/url\(([\'\"])\s*https*:.*([\'\"])\)/si'
  845.             );
  846.             array_push(
  847.                 $bad_attvals{'/.*/'}{'/^style/i'}[1],
  848.                 "url(\\1$trans_image_path\\1)"
  849.             );
  850.         }
  852.         $add_attr_to_tag = array(
  853.             "/^a$/i" =>
  854.                 array('target' => '"_blank"')
  855.         );
  857.         $trusted = $this->tln_sanitize(
  858.             $body,
  859.             $tag_list,
  860.             $rm_tags_with_content,
  861.             $self_closing_tags,
  862.             $force_tag_closing,
  863.             $rm_attnames,
  864.             $bad_attvals,
  865.             $add_attr_to_tag
  866.         );
  867.         return $trusted;
  868.     }
  870.     public function removeEmailReplyQuote($html) {
  871.         $crawler = new Crawler();
  872.         $crawler->addHtmlContent($html);
  874.         //for gmail mail
  875.         
  876.         $crawler->filter('.gmail_extra')->first()->each(function (Crawler $crawler) {
  877.             foreach ($crawler as $node) {
  878.                 $node->parentNode->removeChild($node);
  879.             }
  880.         });    
  882.         //for yahoo mail
  883.         
  884.         $crawler->filter('.qtdSeparateBR')->first()->each(function (Crawler $crawler) {
  885.             foreach ($crawler as $node) {
  886.                 $node->parentNode->removeChild($node);
  887.             }
  888.         });   
  889.         
  890.         $crawler->filter('.yahoo_quoted')->first()->each(function (Crawler $crawler) {
  891.             foreach ($crawler as $node) {
  892.                 $node->parentNode->removeChild($node);
  893.             }
  894.         });
  896.         //for zimbre mail
  897.         
  898.         $crawler->filter('blockquote')->each(function (Crawler $crawler) {
  899.             foreach ($crawler as $node) {
  900.                 if($node->getAttribute('type') == 'cite')
  901.                     $node->removeChild($node);
  902.             }
  903.         });
  904.         
  905.         //for window live mail
  906.         
  907.         $crawler->filter('hr')->each(function (Crawler $crawler) {
  908.             foreach ($crawler as $node) {
  909.                 if($node->getAttribute('stop') == 'Spelling')
  910.                     $node->parentNode->parentNode->removeChild($node->parentNode);
  911.             }
  912.         });
  914.         //for GMX mail
  915.         
  916.         $crawler->filter('div')->each(function (Crawler $crawler) {
  917.             foreach ($crawler as $node) {
  918.                 if($node->getAttribute('name') == 'quote')
  919.                     $node->parentNode->parentNode->removeChild($node->parentNode);
  920.             }
  921.         });
  923.         return $crawler->html();
  924.     }
  926.     public function addClassEmailReplyQuote($html) {
  927.         if(trim($html) == '')
  928.             return '';
  929.         $crawler = new Crawler();
  930.         $crawler->addHtmlContent($html,'UTF-8');
  932.         // $crawler->filter('.gmail_extra')->first()->each(function (Crawler $crawler) {
  933.         //     foreach ($crawler as $node) {
  934.         //         $node->setAttribute('class','gmail_extra helpdesk_blockquote');
  935.         //     }
  936.         // }); 
  937.         $delimiterClass = 'uv-delimiter-dXZkZXNr';
  939.         $crawler->filter('.gmail_quote')->first()->each(function (Crawler $crawler) {
  940.             foreach ($crawler as $node) {
  941.                 $node->setAttribute('class','gmail_quote helpdesk_blockquote');
  942.             }
  943.         }); 
  944.         $crawler->filter('*[class*="' . $delimiterClass .'"]')->first()->each(function (Crawler $crawler) {
  945.             foreach ($crawler as $node) {
  946.                 $node->setAttribute('class','yahoo_quoted helpdesk_blockquote');
  947.             }
  948.         }); 
  949.         $crawler->filter('.zmail_extra')->first()->each(function (Crawler $crawler) {
  950.             foreach ($crawler as $node) {
  951.                 $node->setAttribute('class','yahoo_quoted helpdesk_blockquote');
  952.             }
  953.         });
  954.         // $crawler->filter('blockquote.helpdesk_blockquote[type="cite"]')->first()->each(function (Crawler $crawler) {
  955.         //     foreach ($crawler as $node) {
  956.         //         $node->setAttribute('class','yahoo_quoted helpdesk_blockquote');
  957.         //     }
  958.         // });        
  959.         //for yahoo mail
  961.         $crawler->filter('.qtdSeparateBR')->first()->each(function (Crawler $crawler) {
  962.             foreach ($crawler as $node) {
  963.                 $node->parentNode->removeChild($node);
  964.             }
  965.         });   
  967.         $crawler->filter('.yahoo_quoted')->first()->each(function (Crawler $crawler) {
  968.             foreach ($crawler as $node) {
  969.                 $node->setAttribute('class','yahoo_quoted helpdesk_blockquote');
  970.             }
  971.         });
  973.         //for zimbra mail
  974.         
  975.         $crawler->filter('blockquote')->each(function (Crawler $crawler) {
  976.             foreach ($crawler as $node) {
  977.                 if($node->getAttribute('type') == 'cite')
  978.                     $node->setAttribute('class','helpdesk_blockquote');
  979.                 // $node->parentNode->setAttribute('class','helpdesk_blockquote');
  980.             }
  981.         });
  982.         
  983.         //for window live mail
  984.         
  985.         $crawler->filter('hr')->each(function (Crawler $crawler) {
  986.             foreach ($crawler as $node) {
  987.                 if($node->getAttribute('stop') == 'Spelling')
  988.                     $node->parentNode->parentNode->setAttribute('class','helpdesk_blockquote');
  989.                 elseif($node->getAttribute('id') == 'stopSpelling')
  990.                     $node->parentNode->setAttribute('class','helpdesk_blockquote');
  991.             }
  992.         });
  994.         $crawler->filter('#divRplyFwdMsg')->first()->each(function (Crawler $crawler) {
  995.             foreach ($crawler as $node) {
  996.                 $node->parentNode->setAttribute('class','helpdesk_blockquote');
  997.             }
  998.         });
  1000.         //for GMX mail
  1001.         
  1002.         $crawler->filter('div')->each(function (Crawler $crawler) {
  1003.             foreach ($crawler as $node) {
  1004.                 if($node->getAttribute('name') == 'quote')
  1005.                     $node->setAttribute('class','helpdesk_blockquote');
  1006.             }
  1007.         });
  1009.         return $crawler->html();
  1010.     }
  1012.     public function AutoLinkUrls($str,$popup = FALSE) {
  1013.         $str = $this->AutoEmailUrls($str);
  1014.         if (preg_match_all("#(^|\s|\()((http(s?)://)|(www\.))(\w+[^\s\)\<]+)#i", $str, $matches)){
  1015.             $pop = ($popup == TRUE) ? " target=\"_blank\" " : "";
  1016.             for ($i = 0; $i < count($matches['0']); $i++){
  1017.                 $period = '';
  1018.                 if (preg_match("|\.$|", $matches['6'][$i])){
  1019.                     $period = '.';
  1020.                     $matches['6'][$i] = substr($matches['6'][$i], 0, -1);
  1021.                 }
  1022.                 $str = str_replace($matches['0'][$i],
  1023.                 $matches['1'][$i].'<a href="http'.
  1024.                 $matches['4'][$i].'://'.
  1025.                 $matches['5'][$i].
  1026.                 $matches['6'][$i].'"'.$pop.'>http'.
  1027.                 $matches['4'][$i].'://'.
  1028.                 $matches['5'][$i].
  1029.                 $matches['6'][$i].'</a>'.
  1030.                 $period, $str);
  1031.             }//end for
  1032.         }//end if
  1033.         return $str;
  1034.     }
  1036.     public function AutoEmailUrls($string) {
  1037.         $search  = array('/<p>__<\/p>/', '/([a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4})/');
  1038.         $replace = array('<hr />', '<a href="mailto:$1">$1</a>');
  1039.         return preg_replace($search, $replace, $string);
  1040.     }
  1041. }