program/include/rcube_shared.inc

   1 <?php
   2
   3 /*
   4  +-----------------------------------------------------------------------+
   5  | rcube_shared.inc                                                      |
   6  |                                                                       |
   7  | This file is part of the Roundcube PHP suite                          |
   8  | Copyright (C) 2005-2007, The Roundcube Dev Team                       |
   9  | Licensed under the GNU GPL                                            |
  10  |                                                                       |
  11  | CONTENTS:                                                             |
  12  |   Shared functions and classes used in PHP projects                   |
  13  |                                                                       |
  14  +-----------------------------------------------------------------------+
  15  | Author: Thomas Bruederli <roundcube@gmail.com>                        |
  16  +-----------------------------------------------------------------------+
  17
  18  $Id: rcube_shared.inc 4710 2011-04-29 08:17:42Z alec $
  19
  20 */
  21
  22
  23 /**
  24  * Roundcube shared functions
  25  *
  26  * @package Core
  27  */
  28
  29
  30 /**
  31  * Send HTTP headers to prevent caching this page
  32  */
  33 function send_nocacheing_headers()
  34 {
  35   global $OUTPUT;
  36
  37   if (headers_sent())
  38     return;
  39
  40   header("Expires: ".gmdate("D, d M Y H:i:s")." GMT");
  41   header("Last-Modified: ".gmdate("D, d M Y H:i:s")." GMT");
  42   // Request browser to disable DNS prefetching (CVE-2010-0464)
  43   header("X-DNS-Prefetch-Control: off");
  44
  45   // We need to set the following headers to make downloads work using IE in HTTPS mode.
  46   if ($OUTPUT->browser->ie && rcube_https_check()) {
  47     header('Pragma: private');
  48     header("Cache-Control: private, must-revalidate");
  49   } else {
  50     header("Cache-Control: private, no-cache, must-revalidate, post-check=0, pre-check=0");
  51     header("Pragma: no-cache");
  52   }
  53 }
  54
  55
  56 /**
  57  * Send header with expire date 30 days in future
  58  *
  59  * @param int Expiration time in seconds
  60  */
  61 function send_future_expire_header($offset=2600000)
  62 {
  63   if (headers_sent())
  64     return;
  65
  66   header("Expires: ".gmdate("D, d M Y H:i:s", mktime()+$offset)." GMT");
  67   header("Cache-Control: max-age=$offset");
  68   header("Pragma: ");
  69 }
  70
  71
  72 /**
  73  * Check request for If-Modified-Since and send an according response.
  74  * This will terminate the current script if headers match the given values
  75  *
  76  * @param int Modified date as unix timestamp
  77  * @param string Etag value for caching
  78  */
  79 function send_modified_header($mdate, $etag=null, $skip_check=false)
  80 {
  81   if (headers_sent())
  82     return;
  83
  84   $iscached = false;
  85   $etag = $etag ? "\"$etag\"" : null;
  86
  87   if (!$skip_check)
  88   {
  89     if ($_SERVER['HTTP_IF_MODIFIED_SINCE'] && strtotime($_SERVER['HTTP_IF_MODIFIED_SINCE']) >= $mdate)
  90       $iscached = true;
  91
  92     if ($etag)
  93       $iscached = ($_SERVER['HTTP_IF_NONE_MATCH'] == $etag);
  94   }
  95
  96   if ($iscached)
  97     header("HTTP/1.x 304 Not Modified");
  98   else
  99     header("Last-Modified: ".gmdate("D, d M Y H:i:s", $mdate)." GMT");
 100
 101   header("Cache-Control: private, must-revalidate, max-age=0");
 102   header("Expires: ");
 103   header("Pragma: ");
 104
 105   if ($etag)
 106     header("Etag: $etag");
 107
 108   if ($iscached)
 109     {
 110     ob_end_clean();
 111     exit;
 112     }
 113 }
 114
 115
 116 /**
 117  * Similar function as in_array() but case-insensitive
 118  *
 119  * @param mixed Needle value
 120  * @param array Array to search in
 121  * @return boolean True if found, False if not
 122  */
 123 function in_array_nocase($needle, $haystack)
 124 {
 125   $needle = mb_strtolower($needle);
 126   foreach ($haystack as $value)
 127     if ($needle===mb_strtolower($value))
 128       return true;
 129
 130   return false;
 131 }
 132
 133
 134 /**
 135  * Find out if the string content means TRUE or FALSE
 136  *
 137  * @param string Input value
 138  * @return boolean Imagine what!
 139  */
 140 function get_boolean($str)
 141 {
 142   $str = strtolower($str);
 143   if (in_array($str, array('false', '0', 'no', 'off', 'nein', ''), TRUE))
 144     return FALSE;
 145   else
 146     return TRUE;
 147 }
 148
 149
 150 /**
 151  * Parse a human readable string for a number of bytes
 152  *
 153  * @param string Input string
 154  * @return float Number of bytes
 155  */
 156 function parse_bytes($str)
 157 {
 158   if (is_numeric($str))
 159     return floatval($str);
 160
 161   if (preg_match('/([0-9\.]+)\s*([a-z]*)/i', $str, $regs))
 162   {
 163     $bytes = floatval($regs[1]);
 164     switch (strtolower($regs[2]))
 165     {
 166       case 'g':
 167       case 'gb':
 168         $bytes *= 1073741824;
 169         break;
 170       case 'm':
 171       case 'mb':
 172         $bytes *= 1048576;
 173         break;
 174       case 'k':
 175       case 'kb':
 176         $bytes *= 1024;
 177         break;
 178     }
 179   }
 180
 181   return floatval($bytes);
 182 }
 183
 184 /**
 185  * Create a human readable string for a number of bytes
 186  *
 187  * @param int Number of bytes
 188  * @return string Byte string
 189  */
 190 function show_bytes($bytes)
 191 {
 192   if ($bytes >= 1073741824)
 193   {
 194     $gb = $bytes/1073741824;
 195     $str = sprintf($gb>=10 ? "%d " : "%.1f ", $gb) . rcube_label('GB');
 196   }
 197   else if ($bytes >= 1048576)
 198   {
 199     $mb = $bytes/1048576;
 200     $str = sprintf($mb>=10 ? "%d " : "%.1f ", $mb) . rcube_label('MB');
 201   }
 202   else if ($bytes >= 1024)
 203     $str = sprintf("%d ",  round($bytes/1024)) . rcube_label('KB');
 204   else
 205     $str = sprintf('%d ', $bytes) . rcube_label('B');
 206
 207   return $str;
 208 }
 209
 210 /**
 211  * Convert paths like ../xxx to an absolute path using a base url
 212  *
 213  * @param string Relative path
 214  * @param string Base URL
 215  * @return string Absolute URL
 216  */
 217 function make_absolute_url($path, $base_url)
 218 {
 219   $host_url = $base_url;
 220   $abs_path = $path;
 221
 222   // check if path is an absolute URL
 223   if (preg_match('/^[fhtps]+:\/\//', $path))
 224     return $path;
 225
 226   // cut base_url to the last directory
 227   if (strrpos($base_url, '/')>7)
 228   {
 229     $host_url = substr($base_url, 0, strpos($base_url, '/', 7));
 230     $base_url = substr($base_url, 0, strrpos($base_url, '/'));
 231   }
 232
 233   // $path is absolute
 234   if ($path[0] == '/')
 235     $abs_path = $host_url.$path;
 236   else
 237   {
 238     // strip './' because its the same as ''
 239     $path = preg_replace('/^\.\//', '', $path);
 240
 241     if (preg_match_all('/\.\.\//', $path, $matches, PREG_SET_ORDER))
 242       foreach ($matches as $a_match)
 243       {
 244         if (strrpos($base_url, '/'))
 245           $base_url = substr($base_url, 0, strrpos($base_url, '/'));
 246
 247         $path = substr($path, 3);
 248       }
 249
 250     $abs_path = $base_url.'/'.$path;
 251   }
 252
 253   return $abs_path;
 254 }
 255
 256 /**
 257  * Wrapper function for wordwrap
 258  */
 259 function rc_wordwrap($string, $width=75, $break="\n", $cut=false)
 260 {
 261   $para = explode($break, $string);
 262   $string = '';
 263   while (count($para)) {
 264     $line = array_shift($para);
 265     if ($line[0] == '>') {
 266       $string .= $line.$break;
 267       continue;
 268     }
 269     $list = explode(' ', $line);
 270     $len = 0;
 271     while (count($list)) {
 272       $line = array_shift($list);
 273       $l = mb_strlen($line);
 274       $newlen = $len + $l + ($len ? 1 : 0);
 275
 276       if ($newlen <= $width) {
 277         $string .= ($len ? ' ' : '').$line;
 278         $len += (1 + $l);
 279       } else {
 280         if ($l > $width) {
 281           if ($cut) {
 282             $start = 0;
 283             while ($l) {
 284               $str = mb_substr($line, $start, $width);
 285               $strlen = mb_strlen($str);
 286               $string .= ($len ? $break : '').$str;
 287               $start += $strlen;
 288               $l -= $strlen;
 289               $len = $strlen;
 290             }
 291           } else {
 292                 $string .= ($len ? $break : '').$line;
 293             if (count($list)) $string .= $break;
 294             $len = 0;
 295           }
 296         } else {
 297           $string .= $break.$line;
 298           $len = $l;
 299         }
 300       }
 301     }
 302     if (count($para)) $string .= $break;
 303   }
 304   return $string;
 305 }
 306
 307 /**
 308  * Read a specific HTTP request header
 309  *
 310  * @access static
 311  * @param  string $name Header name
 312  * @return mixed  Header value or null if not available
 313  */
 314 function rc_request_header($name)
 315 {
 316   if (function_exists('getallheaders'))
 317   {
 318     $hdrs = array_change_key_case(getallheaders(), CASE_UPPER);
 319     $key  = strtoupper($name);
 320   }
 321   else
 322   {
 323     $key  = 'HTTP_' . strtoupper(strtr($name, '-', '_'));
 324     $hdrs = array_change_key_case($_SERVER, CASE_UPPER);
 325   }
 326
 327   return $hdrs[$key];
 328   }
 329
 330
 331 /**
 332  * Make sure the string ends with a slash
 333  */
 334 function slashify($str)
 335 {
 336   return unslashify($str).'/';
 337 }
 338
 339
 340 /**
 341  * Remove slash at the end of the string
 342  */
 343 function unslashify($str)
 344 {
 345   return preg_replace('/\/$/', '', $str);
 346 }
 347
 348
 349 /**
 350  * Delete all files within a folder
 351  *
 352  * @param string Path to directory
 353  * @return boolean True on success, False if directory was not found
 354  */
 355 function clear_directory($dir_path)
 356 {
 357   $dir = @opendir($dir_path);
 358   if(!$dir) return FALSE;
 359
 360   while ($file = readdir($dir))
 361     if (strlen($file)>2)
 362       unlink("$dir_path/$file");
 363
 364   closedir($dir);
 365   return TRUE;
 366 }
 367
 368
 369 /**
 370  * Create a unix timestamp with a specified offset from now
 371  *
 372  * @param string String representation of the offset (e.g. 20min, 5h, 2days)
 373  * @param int Factor to multiply with the offset
 374  * @return int Unix timestamp
 375  */
 376 function get_offset_time($offset_str, $factor=1)
 377   {
 378   if (preg_match('/^([0-9]+)\s*([smhdw])/i', $offset_str, $regs))
 379   {
 380     $amount = (int)$regs[1];
 381     $unit = strtolower($regs[2]);
 382   }
 383   else
 384   {
 385     $amount = (int)$offset_str;
 386     $unit = 's';
 387   }
 388
 389   $ts = mktime();
 390   switch ($unit)
 391   {
 392     case 'w':
 393       $amount *= 7;
 394     case 'd':
 395       $amount *= 24;
 396     case 'h':
 397       $amount *= 60;
 398     case 'm':
 399       $amount *= 60;
 400     case 's':
 401       $ts += $amount * $factor;
 402   }
 403
 404   return $ts;
 405 }
 406
 407
 408 /**
 409  * Truncate string if it is longer than the allowed length
 410  * Replace the middle or the ending part of a string with a placeholder
 411  *
 412  * @param string Input string
 413  * @param int    Max. length
 414  * @param string Replace removed chars with this
 415  * @param bool   Set to True if string should be truncated from the end
 416  * @return string Abbreviated string
 417  */
 418 function abbreviate_string($str, $maxlength, $place_holder='...', $ending=false)
 419 {
 420   $length = mb_strlen($str);
 421
 422   if ($length > $maxlength)
 423   {
 424     if ($ending)
 425       return mb_substr($str, 0, $maxlength) . $place_holder;
 426
 427     $place_holder_length = mb_strlen($place_holder);
 428     $first_part_length = floor(($maxlength - $place_holder_length)/2);
 429     $second_starting_location = $length - $maxlength + $first_part_length + $place_holder_length;
 430     $str = mb_substr($str, 0, $first_part_length) . $place_holder . mb_substr($str, $second_starting_location);
 431   }
 432
 433   return $str;
 434 }
 435
 436 /**
 437  * A method to guess the mime_type of an attachment.
 438  *
 439  * @param string $path      Path to the file.
 440  * @param string $name      File name (with suffix)
 441  * @param string $failover  Mime type supplied for failover.
 442  * @param string $is_stream Set to True if $path contains file body
 443  *
 444  * @return string
 445  * @author Till Klampaeckel <till@php.net>
 446  * @see    http://de2.php.net/manual/en/ref.fileinfo.php
 447  * @see    http://de2.php.net/mime_content_type
 448  */
 449 function rc_mime_content_type($path, $name, $failover = 'application/octet-stream', $is_stream=false)
 450 {
 451     $mime_type = null;
 452     $mime_magic = rcmail::get_instance()->config->get('mime_magic');
 453     $mime_ext = @include(RCMAIL_CONFIG_DIR . '/mimetypes.php');
 454     $suffix = $name ? substr($name, strrpos($name, '.')+1) : '*';
 455
 456     // use file name suffix with hard-coded mime-type map
 457     if (is_array($mime_ext)) {
 458         $mime_type = $mime_ext[$suffix];
 459     }
 460     // try fileinfo extension if available
 461     if (!$mime_type && function_exists('finfo_open')) {
 462         if ($finfo = finfo_open(FILEINFO_MIME, $mime_magic)) {
 463             if ($is_stream)
 464                 $mime_type = finfo_buffer($finfo, $path);
 465             else
 466                 $mime_type = finfo_file($finfo, $path);
 467             finfo_close($finfo);
 468         }
 469     }
 470     // try PHP's mime_content_type
 471     if (!$mime_type && !$is_stream && function_exists('mime_content_type')) {
 472       $mime_type = @mime_content_type($path);
 473     }
 474     // fall back to user-submitted string
 475     if (!$mime_type) {
 476         $mime_type = $failover;
 477     }
 478     else {
 479         // Sometimes (PHP-5.3?) content-type contains charset definition,
 480         // Remove it (#1487122) also "charset=binary" is useless
 481         $mime_type = array_shift(preg_split('/[; ]/', $mime_type));
 482     }
 483
 484     return $mime_type;
 485 }
 486
 487
 488 /**
 489  * Detect image type of the given binary data by checking magic numbers
 490  *
 491  * @param string  Binary file content
 492  * @return string Detected mime-type or jpeg as fallback
 493  */
 494 function rc_image_content_type($data)
 495 {
 496     $type = 'jpeg';
 497     if      (preg_match('/^\x89\x50\x4E\x47/', $data)) $type = 'png';
 498     else if (preg_match('/^\x47\x49\x46\x38/', $data)) $type = 'gif';
 499     else if (preg_match('/^\x00\x00\x01\x00/', $data)) $type = 'ico';
 500 //  else if (preg_match('/^\xFF\xD8\xFF\xE0/', $data)) $type = 'jpeg';
 501
 502     return 'image/' . $type;
 503 }
 504
 505
 506 /**
 507  * A method to guess encoding of a string.
 508  *
 509  * @param string $string        String.
 510  * @param string $failover      Default result for failover.
 511  *
 512  * @return string
 513  */
 514 function rc_detect_encoding($string, $failover='')
 515 {
 516     if (!function_exists('mb_detect_encoding')) {
 517         return $failover;
 518     }
 519
 520     // FIXME: the order is important, because sometimes
 521     // iso string is detected as euc-jp and etc.
 522     $enc = array(
 523       'UTF-8', 'SJIS', 'BIG5', 'GB2312',
 524       'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
 525       'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8', 'ISO-8859-9',
 526       'ISO-8859-10', 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'ISO-8859-16',
 527       'WINDOWS-1252', 'WINDOWS-1251', 'EUC-JP', 'EUC-TW', 'KOI8-R',
 528       'ISO-2022-KR', 'ISO-2022-JP'
 529     );
 530
 531     $result = mb_detect_encoding($string, join(',', $enc));
 532
 533     return $result ? $result : $failover;
 534 }
 535
 536 /**
 537  * Removes non-unicode characters from input
 538  *
 539  * @param mixed $input String or array.
 540  * @return string
 541  */
 542 function rc_utf8_clean($input)
 543 {
 544   // handle input of type array
 545   if (is_array($input)) {
 546     foreach ($input as $idx => $val)
 547       $input[$idx] = rc_utf8_clean($val);
 548     return $input;
 549   }
 550
 551   if (!is_string($input) || $input == '')
 552     return $input;
 553
 554   // iconv/mbstring are much faster (especially with long strings)
 555   if (function_exists('mb_convert_encoding') && ($res = mb_convert_encoding($input, 'UTF-8', 'UTF-8')) !== false)
 556     return $res;
 557
 558   if (function_exists('iconv') && ($res = @iconv('UTF-8', 'UTF-8//IGNORE', $input)) !== false)
 559     return $res;
 560
 561   $regexp = '/^('.
 562 //    '[\x00-\x7F]'.                                  // UTF8-1
 563     '|[\xC2-\xDF][\x80-\xBF]'.                      // UTF8-2
 564     '|\xE0[\xA0-\xBF][\x80-\xBF]'.                  // UTF8-3
 565     '|[\xE1-\xEC][\x80-\xBF][\x80-\xBF]'.           // UTF8-3
 566     '|\xED[\x80-\x9F][\x80-\xBF]'.                  // UTF8-3
 567     '|[\xEE-\xEF][\x80-\xBF][\x80-\xBF]'.           // UTF8-3
 568     '|\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF]'.       // UTF8-4
 569     '|[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]'.// UTF8-4
 570     '|\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF]'.       // UTF8-4
 571     ')$/';
 572
 573   $seq = '';
 574   $out = '';
 575
 576   for ($i = 0, $len = strlen($input); $i < $len; $i++) {
 577     $chr = $input[$i];
 578     $ord = ord($chr);
 579     // 1-byte character
 580     if ($ord <= 0x7F) {
 581       if ($seq)
 582         $out .= preg_match($regexp, $seq) ? $seq : '';
 583       $seq = '';
 584       $out .= $chr;
 585     // first (or second) byte of multibyte sequence
 586     } else if ($ord >= 0xC0) {
 587       if (strlen($seq)>1) {
 588         $out .= preg_match($regexp, $seq) ? $seq : '';
 589         $seq = '';
 590       } else if ($seq && ord($seq) < 0xC0) {
 591         $seq = '';
 592       }
 593       $seq .= $chr;
 594     // next byte of multibyte sequence
 595     } else if ($seq) {
 596       $seq .= $chr;
 597     }
 598   }
 599
 600   if ($seq)
 601     $out .= preg_match($regexp, $seq) ? $seq : '';
 602
 603   return $out;
 604 }
 605
 606
 607 /**
 608  * Convert a variable into a javascript object notation
 609  *
 610  * @param mixed Input value
 611  * @return string Serialized JSON string
 612  */
 613 function json_serialize($input)
 614 {
 615   $input = rc_utf8_clean($input);
 616
 617   // sometimes even using rc_utf8_clean() the input contains invalid UTF-8 sequences
 618   // that's why we have @ here
 619   return @json_encode($input);
 620 }
 621
 622
 623 /**
 624  * Explode quoted string
 625  *
 626  * @param string Delimiter expression string for preg_match()
 627  * @param string Input string
 628  */
 629 function rcube_explode_quoted_string($delimiter, $string)
 630 {
 631   $result = array();
 632   $strlen = strlen($string);
 633
 634   for ($q=$p=$i=0; $i < $strlen; $i++) {
 635     if ($string[$i] == "\"" && $string[$i-1] != "\\") {
 636       $q = $q ? false : true;
 637     }
 638     else if (!$q && preg_match("/$delimiter/", $string[$i])) {
 639       $result[] = substr($string, $p, $i - $p);
 640       $p = $i + 1;
 641     }
 642   }
 643
 644   $result[] = substr($string, $p);
 645   return $result;
 646 }
 647
 648
 649 /**
 650  * Get all keys from array (recursive)
 651  *
 652  * @param array Input array
 653  * @return array
 654  */
 655 function array_keys_recursive($array)
 656 {
 657   $keys = array();
 658
 659   if (!empty($array))
 660     foreach ($array as $key => $child) {
 661       $keys[] = $key;
 662       foreach (array_keys_recursive($child) as $val)
 663         $keys[] = $val;
 664     }
 665   return $keys;
 666 }
 667
 668
 669 /**
 670  * mbstring replacement functions
 671  */
 672
 673 if (!extension_loaded('mbstring'))
 674 {
 675     function mb_strlen($str)
 676     {
 677         return strlen($str);
 678     }
 679
 680     function mb_strtolower($str)
 681     {
 682         return strtolower($str);
 683     }
 684
 685     function mb_strtoupper($str)
 686     {
 687         return strtoupper($str);
 688     }
 689
 690     function mb_substr($str, $start, $len=null)
 691     {
 692         return substr($str, $start, $len);
 693     }
 694
 695     function mb_strpos($haystack, $needle, $offset=0)
 696     {
 697         return strpos($haystack, $needle, $offset);
 698     }
 699
 700     function mb_strrpos($haystack, $needle, $offset=0)
 701     {
 702         return strrpos($haystack, $needle, $offset);
 703     }
 704 }
 705
 706 /**
 707  * intl replacement functions
 708  */
 709
 710 if (!function_exists('idn_to_utf8'))
 711 {
 712     function idn_to_utf8($domain, $flags=null)
 713     {
 714         static $idn, $loaded;
 715
 716         if (!$loaded) {
 717             $idn = new Net_IDNA2();
 718             $loaded = true;
 719         }
 720
 721         if ($idn && $domain && preg_match('/(^|\.)xn--/i', $domain)) {
 722             try {
 723                 $domain = $idn->decode($domain);
 724             }
 725             catch (Exception $e) {
 726             }
 727         }
 728         return $domain;
 729     }
 730 }
 731
 732 if (!function_exists('idn_to_ascii'))
 733 {
 734     function idn_to_ascii($domain, $flags=null)
 735     {
 736         static $idn, $loaded;
 737
 738         if (!$loaded) {
 739             $idn = new Net_IDNA2();
 740             $loaded = true;
 741         }
 742
 743         if ($idn && $domain && preg_match('/[^\x20-\x7E]/', $domain)) {
 744             try {
 745                 $domain = $idn->encode($domain);
 746             }
 747             catch (Exception $e) {
 748             }
 749         }
 750         return $domain;
 751     }
 752 }
 753