Source for file typeinfo.php

Documentation is available at typeinfo.php

  1. <?php
  2. /**
  3. * functions for handling types, comparisons, conversions, validation etc
  4. *
  5. * @author    Stuart Prescott
  6. * @copyright  Copyright Stuart Prescott
  7. * @license    http://opensource.org/licenses/gpl-license.php GNU Public License
  8. * @version    $Id$
  9. * @package    Bumblebee
  10. * @subpackage Misc
  11. */
  12.  
  13. checkValidInclude();
  14.  
  15. function checkValidInclude() {
  16.   if (! defined('BUMBLEBEE')) {
  17.     die('Internal error: access denied to this location.');
  18.   }
  19. }
  20.  
  21. /**
  22. * If an array key is set, return that value, else return a default
  23. *
  24. * Combines isset and ternary operator to make for cleaner code that
  25. * is quiet when run with E_ALL.
  26. *
  27. * @param array &$a (passed by ref for efficiency only) array to lookup
  28. * @param string $k  the key to be checked
  29. * @param mixed $default (optional) the default value to return if not index not set
  30. * @return mixed  returns either $a[$k] if it exists or $default
  31. */
  32. function issetSet(&$a, $k, $default=NULL) {
  33.   return (isset($a[$k]) ? $a[$k] : $default);
  34. }
  35.  
  36. /**
  37. * simple debugging function to print out arrays and objects
  38. *
  39. * uses print_r/var_dump or dBug within HTML pre tags for easier inspection of classes and arrays
  40. * @param mixed $v  object or array to print
  41. */
  42. function preDump($v) {
  43.   // either use the dBug class for pretty printing or var_dump/print_r
  44.   $conf = ConfigReader::getInstance();
  45.   if ($conf->value('error_handling', 'UseDBug')) {
  46.     include_once 'dBug.php';
  47.     new dBug($v);
  48.   } else {
  49.     echo '<pre>';
  50.     var_dump($v);
  51.     #print_r($v);
  52.     echo '</pre>'."\n";
  53.   }
  54. }
  55.  
  56. /**
  57. * debugging function to conditionally print data to the browser
  58. * @param mixed $v  variable to be printed
  59. * @param boolean $DEBUG   print data if true
  60. */
  61. function echoData($v, $DEBUG=0) {
  62.   $conf = ConfigReader::getInstance();
  63.   if ($conf->VerboseData || $DEBUG) {
  64.     preDump($v);
  65.   }
  66. }
  67.  
  68.  
  69. /**
  70. * is variable composed purely of alphabetic data [A-Za-z_-]
  71. * @param string $var string to be tested
  72. * @return boolean 
  73. */
  74. function is_alphabetic($var) {
  75.   return preg_match('/^\w+$/', $var);
  76. }
  77.  
  78. /**
  79. * Quote data for passing to the database, enclosing data in quotes etc
  80. *
  81. * @param string $v string to be quoted
  82. * @return string '$v' with slashes added as appropriate.
  83. */
  84. function qw($v) {
  85.   return "'".q($v)."'";
  86. }
  87.  
  88. /**
  89. * Quote data for passing to the database
  90. *
  91. * Fixes programatically generated data so that it is correctly escaped. Deals
  92. * with magic_quotes_gpc to remove slashes so that the input is sensible and
  93. * doesn't end up accummulating escape characters with multiple submissions.
  94. *
  95. * Also tests that the supplied string is actually UTF-8 encoded, as if it is
  96. * correctly UTF-8 encoded then we can be sure that we are protected against
  97. * byte munging multibyte attacks that addslashes() is normally susceptible to.
  98. * (that is where the last byte of a multibyte sequence is 0x5c (\) so
  99. * addslashes() is braindead enough to try and escape it creating a multibyte
  100. * character followed by a backslash.... thus addslashes() has created a SQL
  101. * injection vector rather than closing it.
  102. * For more info see:          http://shiflett.org/archive/184
  103. *
  104. * @param string     $v string to be quoted
  105. * @return string    $v with slashes added as appropriate.
  106. */
  107. function q($v) {
  108.   if (! isUTF8($v)) {
  109.     $orig = $v;
  110.     // badness is here. this means that the user has tried to change the input
  111.     // encoding to something other than the UTF-8 that was requested.
  112.     // We will *try* to fix the string:
  113.     if (function_exists("mb_convert_encoding")) {
  114.       $v = mb_convert_encoding($v, 'UTF-8');
  115.     } elseif (function_exists("iconv")) {
  116.       $v = iconv('', 'UTF-8//IGNORE', $v);
  117.     } else {
  118.       // try converting from windows encoding to UTF-8
  119.       $v = cp1252_to_utf8($v);
  120.     }
  121.     if (!isUTF8($v)) {
  122.       // then we really don't know what to do so kill the data
  123.       // better not to have a compromised db, really...
  124.       $v = '';
  125.     }
  126.     logmsg(9, "Non UTF-8 data received. '$orig' was converted to '$v'.");
  127.     //logmsg(9, "Bacon saved? '".addslashes($orig)."' was converted to '".addslashes($v)."'.");
  128.   }
  129.   // magic-quotes-gpc is a pain in the backside: I would rather I was just given
  130.   // the data the user entered.
  131.   // We can't just return the data if magic_quotes_gpc is turned on because
  132.   // that would be wrong if there was programatically set data in there.
  133.   if (get_magic_quotes_gpc()) {
  134.     // first remove any (partial or full) escaping then add it in properly
  135.     $v = addslashes(stripslashes($v));
  136.   } else {
  137.     // just add in the slashes
  138.     $v = addslashes($v);
  139.   }
  140.   return $v;
  141. }
  142.  
  143. /**
  144. * Quote each element in a set of values.
  145. *
  146. * @param array $list    list of values to qw quote for use in SQL
  147. * @returns array  list of quoted strings
  148. */
  149. function array_qw($list) {
  150.   $newlist = array();
  151.   foreach ($list as $a) {
  152.     $newlist[] = qw($a);
  153.   }
  154.   return $newlist;
  155. }
  156.  
  157. /**
  158. * Remove quoting around expressions and remove slashes in data to escape bad chars
  159. *
  160. * @param string $v string to be unquoted
  161. * @return string unquoted string
  162. */
  163. function unqw($v) {
  164.   if (preg_match("/'(.+)'/", $v, $match)) {
  165.     $v = $match[1];
  166.   }
  167.   return stripslashes($v);
  168. }
  169.  
  170. /**
  171. * Verifies that the supplied string is correctly UTF-8 encoded
  172. *
  173. * Two versions are presented here -- the simple version with just the
  174. * /u regexp is significantly faster than the more complicated byte-checking
  175. * version but the /u regexp doesn't always catch bad UTF-8 sequences.
  176. *
  177. * PCRE /u version from:
  178. *      http://www.phpwact.org/php/i18n/charsets%23checking_utf-8_for_well_formedness
  179. *
  180. * Regexp version from
  181. *      http://w3.org/International/questions/qa-forms-utf-8.html
  182. *
  183. * @param string $v string to be tested
  184. * @return boolean string is UTF-8 encoded
  185. */
  186. function isUTF8($v) {
  187.   return preg_match('@^(?:
  188.           [\x09\x0A\x0D\x20-\x7E]            # ASCII
  189.         | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
  190.         |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
  191.         | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
  192.         |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
  193.         |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
  194.         | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
  195.         |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
  196.   )*$@x', $v);
  197.  
  198. /*
  199.   if ( strlen($str) == 0 ) {
  200.       return TRUE;
  201.   }
  202.   // If even just the first character can be matched, when the /u
  203.   // modifier is used, then it's valid UTF-8. If the UTF-8 is somehow
  204.   // invalid, nothing at all will match, even if the string contains
  205.   // some valid sequences
  206.   return (preg_match('/^.{1}/us',$str,$ar) == 1);
  207. */
  208. }
  209.  
  210. /**
  211. * Converts Windows characters (charset cp-1252 or windows-1252) to UTF-8
  212. *
  213. * @param string $v string to be tested
  214. * @return string UTF-8 string
  215. */
  216. function cp1252_to_utf8($str) {
  217.   if (! function_exists('utf8_encode')) return $str;
  218.   $cp1252_map = array(
  219.     "\xc2\x80" => "\xe2\x82\xac", /* EURO SIGN */
  220.     "\xc2\x82" => "\xe2\x80\x9a", /* SINGLE LOW-9 QUOTATION MARK */
  221.     "\xc2\x83" => "\xc6\x92",     /* LATIN SMALL LETTER F WITH HOOK */
  222.     "\xc2\x84" => "\xe2\x80\x9e", /* DOUBLE LOW-9 QUOTATION MARK */
  223.     "\xc2\x85" => "\xe2\x80\xa6", /* HORIZONTAL ELLIPSIS */
  224.     "\xc2\x86" => "\xe2\x80\xa0", /* DAGGER */
  225.     "\xc2\x87" => "\xe2\x80\xa1", /* DOUBLE DAGGER */
  226.     "\xc2\x88" => "\xcb\x86",     /* MODIFIER LETTER CIRCUMFLEX ACCENT */
  227.     "\xc2\x89" => "\xe2\x80\xb0", /* PER MILLE SIGN */
  228.     "\xc2\x8a" => "\xc5\xa0",     /* LATIN CAPITAL LETTER S WITH CARON */
  229.     "\xc2\x8b" => "\xe2\x80\xb9", /* SINGLE LEFT-POINTING ANGLE QUOTATION */
  230.     "\xc2\x8c" => "\xc5\x92",     /* LATIN CAPITAL LIGATURE OE */
  231.     "\xc2\x8e" => "\xc5\xbd",     /* LATIN CAPITAL LETTER Z WITH CARON */
  232.     "\xc2\x91" => "\xe2\x80\x98", /* LEFT SINGLE QUOTATION MARK */
  233.     "\xc2\x92" => "\xe2\x80\x99", /* RIGHT SINGLE QUOTATION MARK */
  234.     "\xc2\x93" => "\xe2\x80\x9c", /* LEFT DOUBLE QUOTATION MARK */
  235.     "\xc2\x94" => "\xe2\x80\x9d", /* RIGHT DOUBLE QUOTATION MARK */
  236.     "\xc2\x95" => "\xe2\x80\xa2", /* BULLET */
  237.     "\xc2\x96" => "\xe2\x80\x93", /* EN DASH */
  238.     "\xc2\x97" => "\xe2\x80\x94", /* EM DASH */
  239.     "\xc2\x98" => "\xcb\x9c",     /* SMALL TILDE */
  240.     "\xc2\x99" => "\xe2\x84\xa2", /* TRADE MARK SIGN */
  241.     "\xc2\x9a" => "\xc5\xa1",     /* LATIN SMALL LETTER S WITH CARON */
  242.     "\xc2\x9b" => "\xe2\x80\xba", /* SINGLE RIGHT-POINTING ANGLE QUOTATION*/
  243.     "\xc2\x9c" => "\xc5\x93",     /* LATIN SMALL LIGATURE OE */
  244.     "\xc2\x9e" => "\xc5\xbe",     /* LATIN SMALL LETTER Z WITH CARON */
  245.     "\xc2\x9f" => "\xc5\xb8"      /* LATIN CAPITAL LETTER Y WITH DIAERESIS*/
  246.   );
  247.   // utf8_encode() converts from ISO-8859-1 to UTF-8; the strtr() converts the
  248.   // differences between Windows-1252 and ISO-8859-1.
  249.   return  strtr(utf8_encode($str), $cp1252_map);
  250. }
  251.  
  252. /**
  253. * quote words against XSS attacks by converting tags to html entities
  254. *
  255. * replace some bad HTML characters with entities to protext against
  256. * cross-site scripting attacks. the generated code should be clean of
  257. * nasty HTML
  258. *
  259. * @param string $v string to be quoted
  260. * @param boolean $strip   strip slashes first
  261. * @return string $v with html converted to entities
  262. */
  263. function xssqw($v, $strip=true) {
  264.   // once again magic_quotes_gpc gets in the way
  265.   if ($strip && get_magic_quotes_gpc()) {
  266.     // first remove any (partial or full) escaping then we'll do it properly below
  267.     $v = stripslashes($v);
  268.   }
  269.   $replace = array(
  270.         "/'/"                             =>   "&#039;",
  271.         '/"/'                             =>   "&#034;",
  272.         '@<@'                             =>   '&lt;',
  273.         '@>@'                             =>   '&gt;',
  274.         '@&(?!(\#\d{1,4})|(\w{2,4});)@'   =>   '&amp;'  // allow &#123; and &lt; through
  275.   );
  276.   return preg_replace(array_keys($replace), array_values($replace), $v);
  277.   #return htmlentities($v, ENT_QUOTES);
  278. }
  279.  
  280.  
  281. /**
  282. * quote words against XSS attacks but allow some html tags through
  283. * (unsafe attributes are removed)
  284. *
  285. * @param string $v string to be quoted
  286. * @return string $v with html converted to entities
  287. */
  288. function xssqw_relaxed($v) {
  289.   // once again magic_quotes_gpc gets in the way
  290.   if (get_magic_quotes_gpc()) {
  291.     // first remove any (partial or full) escaping then we'll do it properly below
  292.     $v = stripslashes($v);
  293.   }
  294.   $keep = array(
  295.           "i"     => array("style", "class"),
  296.           "u"     => array("style", "class"),
  297.           "b"     => array("style", "class"),
  298.           "a"     => array("style", "class", "href", "id", "name"),
  299.           "div"   => array("style", "class", "id"),
  300.           "br"    => array(),
  301.           "hr"    => array("style", "class", "id")
  302.         );
  303.  
  304.   $s = xssqw($v);
  305.   foreach ($keep as $tag => $attribs) {
  306.     $s = preg_replace("@&lt;\s*($tag)((?:(?!&gt;).)*)&gt;"
  307.                       ."((?:(?!&lt;\s*/\s*$tag).)*)"  // negative lookahead: no closing tag
  308.                       ."&lt;\s*/$tag\s*&gt;@ise",
  309.                       'xssqw_relaxed_helper($keep, "\1", "\2", "\3");',
  310.                       $s);
  311.     #echo $s;
  312.   }
  313.   return $s;
  314. }
  315.  
  316. function xssqw_relaxed_helper($tags, $tag, $attribs, $content){
  317.   #echo "tag='$tag'; attribs='$attribs'; content='$content'<br />\n";
  318.   $attrlist = array();
  319.   foreach ($tags[$tag] as $a) {
  320.     $attrmatch = "@$a\s*=\s*(&#039;|&#034;)((?:[^\\1])*)\\1@";
  321.     $m = array();
  322.     if (preg_match($attrmatch, $attribs, $m)) {
  323.       $attrlist[] = "$a='$m[2]'";
  324.     }
  325.   }
  326.   $attrs = join($attrlist, " ");
  327.   return "<$tag $attrs>$content</$tag>";
  328. }
  329.  
  330. /**
  331. * quote all elements of an array against XSS attacks using xssqw function
  332. *
  333. * @param array $a array of strings to be quoted
  334. * @return array $a of strings quoted
  335. */
  336. function array_xssqw($a) {
  337.   return array_map('xssqw', $a);
  338. }
  339.  
  340. /**
  341. * tests if string is non-empty
  342. *
  343. * note that in PHP, '' == '0' etc so test has to use strlen
  344. * @param string $v string to test for emptiness
  345. * @return boolean 
  346. */
  347. function is_nonempty_string($v) {
  348.   #echo "'val=$v' ";
  349.   return !(strlen($v) == 0);
  350. }
  351.  
  352. /**
  353. * tests if string is a plausible member of a radio-button choice set
  354. *
  355. * @param string $v string to test
  356. * @return boolean 
  357. */
  358. function choice_set($v) {
  359.   #echo "'val=$v' ";
  360.   return !($v == NULL || $v == '');
  361. }
  362.  
  363. /**
  364. * tests if string is a member of a radio button choice set
  365. *
  366. * @param string $v string to test
  367. * @return boolean 
  368. */
  369. function is_valid_radiochoice($v) {
  370.   #echo "'val=$v' ";
  371.   return (choice_set($v) && is_numeric($v) && $v >= -1);
  372. }
  373.  
  374. /**
  375. * tests if string is a sensible email format
  376. *
  377. * does not test full RFC822 compliance or that the address exists, just that it looks
  378. * like a standard email address with a username part @ and domain part with at least one dot
  379. * @param string $v string to test for email format
  380. * @return boolean 
  381. */
  382. function is_email_format($v) {
  383.   #echo "'val=$v' ";
  384.   #$pattern = '/^\w.+\@[A-Z_\-]+\.[A-Z_\-]/i';
  385.   $pattern = '/^[_a-z0-9\-]+(?:\.[_a-z0-9\-]+)*@[a-z0-9\-]+(?:\.[a-z0-9\-]{2,})+$/i';
  386.   return (preg_match($pattern, $v));
  387. }
  388.  
  389. /**
  390. * tests if string is number
  391. *
  392. * @param string $v string to test if it is a number
  393. * @return boolean 
  394. */
  395. function is_number($v) {
  396.   return is_numeric($v);
  397. }
  398.  
  399. /**
  400. * tests if string is a amount for a price
  401. *
  402. * @param string $v string to test if it is a valid cost
  403. * @return boolean 
  404. * @todo //TODO: strengthen this test?
  405. */
  406. function is_cost_amount($v) {
  407.    return is_numeric($v);
  408. }
  409.  
  410. /**
  411. * tests if string is a amount for a price but allows blank entries
  412. *
  413. * @param string $v string to test if it is a valid cost
  414. * @return boolean 
  415. */
  416. function is_cost_amount_or_blank($v) {
  417.    return is_number($v) || $v === '' || $v === null;
  418. }
  419.  
  420. /**
  421. * tests if string is valid date-time expression YYYY-MM-DD HH:MM
  422. *
  423. * @param string $v string to test it is a date-time string
  424. * @return boolean 
  425. * @todo //TODO: can this be relaxed to be more user-friendly without introducing errors
  426. */
  427. function is_valid_datetime($v) {
  428.   return (preg_match('/^\d\d\d\d-\d\d-\d\d \d\d:\d\d/',$v));
  429. }
  430.  
  431. /**
  432. * tests if string is valid time expression HH:MM or HH:MM:SS format
  433. *
  434. * @param string $v string to test it is a time string
  435. * @return boolean 
  436. * @todo //TODO: can this be relaxed to be more user-friendly without introducing errors
  437. */
  438. function is_valid_time($v) {
  439.   return (preg_match('/^\d\d:\d\d/',$v) || preg_match('/^\d\d:\d\d:\d\d/',$v));
  440. }
  441.  
  442. /**
  443. * tests if string is valid time expression HH:MM or HH:MM:SS format other than 00:00:00
  444. *
  445. * @param string $v string to test if it is a time string
  446. * @return boolean 
  447. * @todo //TODO: can this be relaxed to be more user-friendly without introducing errors
  448. */
  449. function is_valid_nonzero_time($v) {
  450.   return (preg_match('/^\d\d:\d\d/',$v) || preg_match('/^\d\d:\d\d:\d\d/',$v))
  451.             && ! preg_match('/^00:00/',$v) && ! preg_match('/^00:00:00/',$v);
  452. }
  453.  
  454. /**
  455. * tests if a set of numbers add to 100 (set of percentages should add to 100)
  456. *
  457. * @param array $vs list of values to test if sum is 100
  458. * @return boolean 
  459. */
  460. function sum_is_100($vs) {
  461.   #echo "<br/>Checking sum<br/>";
  462.   $sum=0;
  463.   foreach ($vs as $v) {
  464.     #echo "'$v', ";
  465.     $sum += $v;
  466.   }
  467.   return ($sum == 100);
  468. }
  469.  
  470. function currencyValueCleaner($value) {
  471.   $conf = ConfigReader::getInstance();
  472.   $re = $conf->value('language', 'removedCurrencySymbols');
  473.   if ($re == '' || $re == null) return;
  474.  
  475.   $re = preg_quote($re, '@');
  476.   $value = preg_replace("@[$re]@", '', $value);
  477.   return trim($value);
  478. }
  479.  
  480. function numberFormatter($value, $dp) {
  481.   $conf = ConfigReader::getInstance();
  482.   return number_format($value, $dp,
  483.                        $conf->value('language', 'decimal_separator',   '.'),
  484.                        $conf->value('language', 'thousands_separator', ''));
  485. }
  486.  
  487. function currencyFormatter($value) {
  488.   $conf = ConfigReader::getInstance();
  489.   $s = number_format($value,
  490.                       $conf->value('language', 'money_decimal_places',   2),
  491.                       $conf->value('language', 'decimal_separator',      '.'),
  492.                       $conf->value('language', 'thousands_separator',    ''));
  493.   return sprintf($conf->value('language', 'money_format',   '$%s'), $s);
  494. }
  495.  
  496. function commaFloat($str) {
  497.   if(strstr($str, ',')) {
  498.     $str = str_replace('.', '',  $str); // remove dots that are (thousand seps)
  499.     $str = str_replace(',', '.', $str); // replace ',' with '.'
  500.   }
  501.   return floatval($str); // take some last chances with floatval
  502. }
  503.  
  504.  
  505. ?>

Documentation generated on Tue, 06 Mar 2007 10:02:05 +0000 by phpDocumentor 1.3.0