Source for file url_parser.php

Documentation is available at url_parser.php

  1. <?php
  2.  
  3. /**
  4.  * url_parser.php
  5.  *
  6.  * This code provides various string manipulation functions that are
  7.  * used by the rest of the SquirrelMail code.
  8.  *
  9.  * @copyright 1999-2014 The SquirrelMail Project Team
  10.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  11.  * @version $Id: url_parser.php 14422 2014-01-01 20:59:43Z pdontthink $
  12.  * @package squirrelmail
  13.  */
  14.  
  15. /**
  16.  * Undocumented - complain, then patch.
  17.  */
  18. function replaceBlock (&$in$replace$start$end{
  19.     $begin substr($in,0,$start);
  20.     $end   substr($in,$end,strlen($in)-$end);
  21.     $in    $begin.$replace.$end;
  22. }
  23.  
  24. /* Having this defined in just one spot could help when changes need
  25.  * to be made to the pattern
  26.  * Make sure that the expression is evaluated case insensitively
  27.  *
  28.  * Here's pretty sophisticated IP matching:
  29.  * $IPMatch = '(2[0-5][0-9]|1?[0-9]{1,2})';
  30.  * $IPMatch = '\[?' . $IPMatch . '(\.' . $IPMatch . '){3}\]?';
  31.  */
  32. /* Here's enough: */
  33. global $IP_RegExp_Match$Host_RegExp_Match$Email_RegExp_Match;
  34. $IP_RegExp_Match '\\[?[0-9]{1,3}(\\.[0-9]{1,3}){3}\\]?';
  35. $Host_RegExp_Match '(' $IP_RegExp_Match .
  36.     '|[0-9a-z]([-.]?[0-9a-z])*\\.[a-z][a-z]+)';
  37. $Email_RegExp_Match '[0-9a-z]([-_.+]?[0-9a-z])*(%' $Host_RegExp_Match .
  38.     ')?@' $Host_RegExp_Match;
  39.  
  40. /**
  41.  * rfc 2368 (mailto URL) preg_match() regexp
  42.  * @link http://www.ietf.org/rfc/rfc2368.txt
  43.  * @global string MailTo_PReg_Match the encapsulated regexp for preg_match()
  44.  */
  45. global $MailTo_PReg_Match;
  46. $Mailto_Email_RegExp '[0-9a-z%]([-_.+%]?[0-9a-z])*(%' $Host_RegExp_Match ')?@' $Host_RegExp_Match;
  47. $MailTo_PReg_Match '/((?:' $Mailto_Email_RegExp ')*)((?:\?(?:to|cc|bcc|subject|body)=[^\s\?&=,()]+)?(?:&amp;(?:to|cc|bcc|subject|body)=[^\s\?&=,()]+)*)/i';
  48.  
  49. function parseEmail (&$body{
  50.     global $color$Email_RegExp_Match$compose_new_win;
  51.     $sbody     $body;
  52.     $addresses array();
  53.  
  54.     /* Find all the email addresses in the body */
  55.     while(preg_match('/'.$Email_RegExp_Match.'/i'$sbody$regs)) {
  56.         $addresses[$regs[0]] $regs[0];
  57.         $start strpos($sbody$regs[0]strlen($regs[0]);
  58.         $sbody substr($sbody$start);
  59.     }
  60.     /* Replace each email address with a compose URL */
  61.     foreach ($addresses as $email{
  62.         $comp_uri makeComposeLink('src/compose.php?send_to='.urlencode($email)$email);
  63.         $body str_replace($email$comp_uri$body);
  64.     }
  65.     /* Return number of unique addresses found */
  66.     return count($addresses);
  67. }
  68.  
  69.  
  70. /* We don't want to re-initialize this stuff for every line.  Save work
  71.  * and just do it once here.
  72.  */
  73. global $url_parser_url_tokens;
  74. $url_parser_url_tokens array(
  75.     'http://',
  76.     'https://',
  77.     'ftp://',
  78.     'telnet:',  // Special case -- doesn't need the slashes
  79.     'mailto:',  // Special case -- doesn't use the slashes
  80.     'gopher://',
  81.     'news://');
  82.  
  83. global $url_parser_poss_ends;
  84. $url_parser_poss_ends array(' '"\n""\r"'<''>'".\r"".\n",
  85.     '.&nbsp;''&nbsp;'')''(''&quot;''&lt;''&gt;''.<',
  86.     ']''[''{''}'"\240"', ''. '",\n"",\r");
  87.  
  88.  
  89. /**
  90.  * Parses a body and converts all found URLs to clickable links.
  91.  *
  92.  * @param string body the body to process, by ref
  93.  * @return void 
  94.  */
  95. function parseUrl (&$body{
  96.     global $url_parser_poss_ends$url_parser_url_tokens;
  97.     $start      0;
  98.     $blength    strlen($body);
  99.  
  100.     while ($start $blength{
  101.         $target_token '';
  102.         $target_pos $blength;
  103.  
  104.         /* Find the first token to replace */
  105.         foreach ($url_parser_url_tokens as $the_token{
  106.             $pos strpos(strtolower($body)$the_token$start);
  107.             if (is_int($pos&& $pos $target_pos{
  108.                 $target_pos   $pos;
  109.                 $target_token $the_token;
  110.             }
  111.         }
  112.  
  113.         /* Look for email addresses between $start and $target_pos */
  114.         $check_str substr($body$start$target_pos-$start);
  115.  
  116.         if (parseEmail($check_str)) {
  117.             replaceBlock($body$check_str$start$target_pos);
  118.             $blength    strlen($body);
  119.             $target_pos strlen($check_str$start;
  120.         }
  121.  
  122.         // rfc 2368 (mailto URL)
  123.         if ($target_token == 'mailto:'{    
  124.             $target_pos += 7;    //skip mailto:
  125.             $end $blength;
  126.  
  127.             $mailto substr($body$target_pos$end-$target_pos);
  128.  
  129.             global $MailTo_PReg_Match;
  130.             if ((preg_match($MailTo_PReg_Match$mailto$regs)) && ($regs[0!= '')) {
  131.                 $mailto_before $target_token $regs[0];
  132.                 /**
  133.                  * '+' characters in a mailto URI don't need to be percent-encoded.
  134.                  * However, when mailto URI data is transported via HTTP, '+' must
  135.                  * be percent-encoded as %2B so that when the HTTP data is
  136.                  * percent-decoded, you get '+' back and not a space.
  137.                  */
  138.                 $mailto_params str_replace("+""%2B"$regs[10]);
  139.                 if ($regs[1]{    //if there is an email addr before '?', we need to merge it with the params
  140.                     $to 'to=' str_replace("+""%2B"$regs[1]);
  141.                     if (strpos($mailto_params'to='> -1)    //already a 'to='
  142.                         $mailto_params str_replace('to='$to '%2C%20'$mailto_params);
  143.                     else {
  144.                         if ($mailto_params)    //already some params, append to them
  145.                             $mailto_params .= '&amp;' $to;
  146.                         else
  147.                             $mailto_params .= '?' $to;
  148.                     }
  149.                 }
  150.                 $url_str preg_replace(array('/to=/i''/(?<!b)cc=/i''/bcc=/i')array('send_to=''send_to_cc=''send_to_bcc=')$mailto_params);
  151.                 $comp_uri makeComposeLink('src/compose.php' $url_str$mailto_before);
  152.                 replaceBlock($body$comp_uri$target_pos 7$target_pos strlen($regs[0]));
  153.                 $target_pos += strlen($comp_uri7;
  154.             }
  155.         }
  156.         else
  157.         /* If there was a token to replace, replace it */
  158.         if ($target_token != ''{
  159.             /* Find the end of the URL */
  160.             $end $blength;
  161.             foreach ($url_parser_poss_ends as $val{
  162.                 $enda strpos($body$val$target_pos);
  163.                 if (is_int($enda&& $enda $end{
  164.                     $end $enda;
  165.                 }
  166.             }
  167.  
  168.             /* make sure that there are no 8bit chars between $target_pos and suspected end of URL */
  169.             if (!is_bool($first8bit=sq_strpos_8bit($body,$target_pos,$end))) {
  170.                 $end $first8bit;
  171.             }
  172.  
  173.             /* Extract URL */
  174.             $url substr($body$target_pos$end-$target_pos);
  175.  
  176.             /* Needed since lines are not passed with \n or \r */
  177.             while preg_match('/[,.]$/'$url) ) {
  178.                 $url substr$url0-);
  179.                 $end--;
  180.             }
  181.  
  182.             /* Replace URL with HyperLinked Url, requires 1 char in link */
  183.             if ($url != '' && $url != $target_token{
  184.                 $url_str "<a href=\"$url\" target=\"_blank\">$url</a>";
  185.                 replaceBlock($body,$url_str,$target_pos,$end);
  186.                 $target_pos += strlen($url_str);
  187.             }
  188.             else {
  189.                 // Not quite a valid link, skip ahead to next chance
  190.                 $target_pos += strlen($target_token);
  191.             }
  192.         }
  193.  
  194.         /* Move forward */
  195.         $start   $target_pos;
  196.         $blength strlen($body);
  197.     }
  198. }
  199.  
  200. /**
  201.  * Finds first occurrence of 8bit data in the string
  202.  *
  203.  * Function finds first 8bit symbol or html entity that represents 8bit character.
  204.  * Search start is defined by $offset argument. Search ends at $maxlength position.
  205.  * If $maxlength is not defined or bigger than provided string, search ends when
  206.  * string ends.
  207.  *
  208.  * Check returned data type in order to avoid confusion between bool(false)
  209.  * (not found) and int(0) (first char in the string).
  210.  * @param string $haystack 
  211.  * @param integer $offset 
  212.  * @param integer $maxlength 
  213.  * @return mixed integer with first 8bit character position or boolean false
  214.  * @since 1.5.2 and 1.4.7
  215.  */
  216. function sq_strpos_8bit($haystack,$offset=0,$maxlength=false{
  217.     $ret false;
  218.     
  219.     if ($maxlength===false || strlen($haystack$maxlength{
  220.         $maxlength=strlen($haystack);
  221.     }
  222.  
  223.     for($i=$offset;$i<$maxlength;$i++{
  224.         /* rh7-8 compatibility. don't use full 8bit range in regexp */
  225.         if (preg_match('/[\200-\237]|\240|[\241-\377]/',$haystack[$i])) {
  226.             /* we have 8bit char. stop here and return position */
  227.             $ret $i;
  228.             break;
  229.         elseif ($haystack[$i]=='&'{
  230.             $substring substr($haystack,$i);
  231.             /**
  232.              * 1. look for "&#(decimal number);" where decimal_number is bigger than 127
  233.              * 2. look for "&x(hexadecimal number);", where hex number is bigger than x7f
  234.              * 3. look for any html character entity that is not 7bit html special char. Use 
  235.              * own sq_get_html_translation_table() function with 'utf-8' character set in 
  236.              * order to get all html entities.
  237.              */
  238.             if ((preg_match('/^&#(\d+);/',$substring,$match&& $match[1]>127||
  239.                 (preg_match('/^&x([0-9a-f]+);/i',$substring,$match&& $match[1]>"\x7f"||
  240.                 (preg_match('/^&([a-z]+);/i',$substring,$match&& 
  241.                  !in_array($match[0],get_html_translation_table(HTML_SPECIALCHARS)) && 
  242.                  in_array($match[0],sq_get_html_translation_table(HTML_ENTITIES,ENT_COMPAT,'utf-8')))) {
  243.                 $ret $i;
  244.                 break;
  245.             }
  246.         }
  247.     }
  248.     return $ret;
  249. }

Documentation generated on Sat, 20 Dec 2014 04:21:58 +0100 by phpDocumentor 1.4.3