1117 lines
40 KiB
PHP
1117 lines
40 KiB
PHP
<?php
|
|
/**
|
|
* Validation class
|
|
*
|
|
* Copyright (c) 1997-2006 Pierre-Alain Joye,Tomas V.V.Cox, Amir Saied
|
|
*
|
|
* This source file is subject to the New BSD license, That is bundled
|
|
* with this package in the file LICENSE, and is available through
|
|
* the world-wide-web at
|
|
* http://www.opensource.org/licenses/bsd-license.php
|
|
* If you did not receive a copy of the new BSDlicense and are unable
|
|
* to obtain it through the world-wide-web, please send a note to
|
|
* pajoye@php.net so we can mail you a copy immediately.
|
|
*
|
|
* Author: Tomas V.V.Cox <cox@idecnet.com>
|
|
* Pierre-Alain Joye <pajoye@php.net>
|
|
* Amir Mohammad Saied <amir@php.net>
|
|
*
|
|
*
|
|
* Package to validate various datas. It includes :
|
|
* - numbers (min/max, decimal or not)
|
|
* - email (syntax, domain check)
|
|
* - string (predifined type alpha upper and/or lowercase, numeric,...)
|
|
* - date (min, max, rfc822 compliant)
|
|
* - uri (RFC2396)
|
|
* - possibility valid multiple data with a single method call (::multiple)
|
|
*
|
|
* @category Validate
|
|
* @package Validate
|
|
* @author Tomas V.V.Cox <cox@idecnet.com>
|
|
* @author Pierre-Alain Joye <pajoye@php.net>
|
|
* @author Amir Mohammad Saied <amir@php.net>
|
|
* @copyright 1997-2006 Pierre-Alain Joye,Tomas V.V.Cox,Amir Mohammad Saied
|
|
* @license http://www.opensource.org/licenses/bsd-license.php New BSD License
|
|
* @version CVS: $Id: Validate.php,v 1.134 2009/01/28 12:27:33 davidc Exp $
|
|
* @link http://pear.php.net/package/Validate
|
|
*/
|
|
|
|
/**
|
|
* Methods for common data validations
|
|
*/
|
|
define('VALIDATE_NUM', '0-9');
|
|
define('VALIDATE_SPACE', '\s');
|
|
define('VALIDATE_ALPHA_LOWER', 'a-z');
|
|
define('VALIDATE_ALPHA_UPPER', 'A-Z');
|
|
define('VALIDATE_ALPHA', VALIDATE_ALPHA_LOWER . VALIDATE_ALPHA_UPPER);
|
|
define('VALIDATE_EALPHA_LOWER', VALIDATE_ALPHA_LOWER . 'áéíóúýàèìòùäëïöüÿâêîôûãñõ¨åæç½ðøþß');
|
|
define('VALIDATE_EALPHA_UPPER', VALIDATE_ALPHA_UPPER . 'ÁÉÍÓÚÝÀÈÌÒÙÄËÏÖܾÂÊÎÔÛÃÑÕ¦ÅÆǼÐØÞ');
|
|
define('VALIDATE_EALPHA', VALIDATE_EALPHA_LOWER . VALIDATE_EALPHA_UPPER);
|
|
define('VALIDATE_PUNCTUATION', VALIDATE_SPACE . '\.,;\:&"\'\?\!\(\)');
|
|
define('VALIDATE_NAME', VALIDATE_EALPHA . VALIDATE_SPACE . "'" . "-");
|
|
define('VALIDATE_STREET', VALIDATE_NUM . VALIDATE_NAME . "/\\ºª\.");
|
|
|
|
define('VALIDATE_ITLD_EMAILS', 1);
|
|
define('VALIDATE_GTLD_EMAILS', 2);
|
|
define('VALIDATE_CCTLD_EMAILS', 4);
|
|
define('VALIDATE_ALL_EMAILS', 8);
|
|
|
|
/**
|
|
* Validation class
|
|
*
|
|
* Package to validate various datas. It includes :
|
|
* - numbers (min/max, decimal or not)
|
|
* - email (syntax, domain check)
|
|
* - string (predifined type alpha upper and/or lowercase, numeric,...)
|
|
* - date (min, max)
|
|
* - uri (RFC2396)
|
|
* - possibility valid multiple data with a single method call (::multiple)
|
|
*
|
|
* @category Validate
|
|
* @package Validate
|
|
* @author Tomas V.V.Cox <cox@idecnet.com>
|
|
* @author Pierre-Alain Joye <pajoye@php.net>
|
|
* @author Amir Mohammad Saied <amir@php.net>
|
|
* @copyright 1997-2006 Pierre-Alain Joye,Tomas V.V.Cox,Amir Mohammad Saied
|
|
* @license http://www.opensource.org/licenses/bsd-license.php New BSD License
|
|
* @version Release: @package_version@
|
|
* @link http://pear.php.net/package/Validate
|
|
*/
|
|
class Validate
|
|
{
|
|
/**
|
|
* International Top-Level Domain
|
|
*
|
|
* This is an array of the known international
|
|
* top-level domain names.
|
|
*
|
|
* @access protected
|
|
* @var array $_iTld (International top-level domains)
|
|
*/
|
|
var $_itld = array(
|
|
'arpa',
|
|
'root',
|
|
);
|
|
|
|
/**
|
|
* Generic top-level domain
|
|
*
|
|
* This is an array of the official
|
|
* generic top-level domains.
|
|
*
|
|
* @access protected
|
|
* @var array $_gTld (Generic top-level domains)
|
|
*/
|
|
var $_gtld = array(
|
|
'aero',
|
|
'biz',
|
|
'cat',
|
|
'com',
|
|
'coop',
|
|
'edu',
|
|
'gov',
|
|
'info',
|
|
'int',
|
|
'jobs',
|
|
'mil',
|
|
'mobi',
|
|
'museum',
|
|
'name',
|
|
'net',
|
|
'org',
|
|
'pro',
|
|
'travel',
|
|
'asia',
|
|
'post',
|
|
'tel',
|
|
'geo',
|
|
);
|
|
|
|
/**
|
|
* Country code top-level domains
|
|
*
|
|
* This is an array of the official country
|
|
* codes top-level domains
|
|
*
|
|
* @access protected
|
|
* @var array $_ccTld (Country Code Top-Level Domain)
|
|
*/
|
|
var $_cctld = array(
|
|
'ac',
|
|
'ad','ae','af','ag',
|
|
'ai','al','am','an',
|
|
'ao','aq','ar','as',
|
|
'at','au','aw','ax',
|
|
'az','ba','bb','bd',
|
|
'be','bf','bg','bh',
|
|
'bi','bj','bm','bn',
|
|
'bo','br','bs','bt',
|
|
'bu','bv','bw','by',
|
|
'bz','ca','cc','cd',
|
|
'cf','cg','ch','ci',
|
|
'ck','cl','cm','cn',
|
|
'co','cr','cs','cu',
|
|
'cv','cx','cy','cz',
|
|
'de','dj','dk','dm',
|
|
'do','dz','ec','ee',
|
|
'eg','eh','er','es',
|
|
'et','eu','fi','fj',
|
|
'fk','fm','fo','fr',
|
|
'ga','gb','gd','ge',
|
|
'gf','gg','gh','gi',
|
|
'gl','gm','gn','gp',
|
|
'gq','gr','gs','gt',
|
|
'gu','gw','gy','hk',
|
|
'hm','hn','hr','ht',
|
|
'hu','id','ie','il',
|
|
'im','in','io','iq',
|
|
'ir','is','it','je',
|
|
'jm','jo','jp','ke',
|
|
'kg','kh','ki','km',
|
|
'kn','kp','kr','kw',
|
|
'ky','kz','la','lb',
|
|
'lc','li','lk','lr',
|
|
'ls','lt','lu','lv',
|
|
'ly','ma','mc','md',
|
|
'me','mg','mh','mk',
|
|
'ml','mm','mn','mo',
|
|
'mp','mq','mr','ms',
|
|
'mt','mu','mv','mw',
|
|
'mx','my','mz','na',
|
|
'nc','ne','nf','ng',
|
|
'ni','nl','no','np',
|
|
'nr','nu','nz','om',
|
|
'pa','pe','pf','pg',
|
|
'ph','pk','pl','pm',
|
|
'pn','pr','ps','pt',
|
|
'pw','py','qa','re',
|
|
'ro','rs','ru','rw',
|
|
'sa','sb','sc','sd',
|
|
'se','sg','sh','si',
|
|
'sj','sk','sl','sm',
|
|
'sn','so','sr','st',
|
|
'su','sv','sy','sz',
|
|
'tc','td','tf','tg',
|
|
'th','tj','tk','tl',
|
|
'tm','tn','to','tp',
|
|
'tr','tt','tv','tw',
|
|
'tz','ua','ug','uk',
|
|
'us','uy','uz','va',
|
|
'vc','ve','vg','vi',
|
|
'vn','vu','wf','ws',
|
|
'ye','yt','yu','za',
|
|
'zm','zw',
|
|
);
|
|
|
|
/**
|
|
* Validate a tag URI (RFC4151)
|
|
*
|
|
* @param string $uri tag URI to validate
|
|
*
|
|
* @return boolean true if valid tag URI, false if not
|
|
*
|
|
* @access private
|
|
*/
|
|
function __uriRFC4151($uri)
|
|
{
|
|
$datevalid = false;
|
|
if (preg_match(
|
|
'/^tag:(?<name>.*),(?<date>\d{4}-?\d{0,2}-?\d{0,2}):(?<specific>.*)(.*:)*$/', $uri, $matches)) {
|
|
$date = $matches['date'];
|
|
$date6 = strtotime($date);
|
|
if ((strlen($date) == 4) && $date <= date('Y')) {
|
|
$datevalid = true;
|
|
} elseif ((strlen($date) == 7) && ($date6 < strtotime("now"))) {
|
|
$datevalid = true;
|
|
} elseif ((strlen($date) == 10) && ($date6 < strtotime("now"))) {
|
|
$datevalid = true;
|
|
}
|
|
if (self::email($matches['name'])) {
|
|
$namevalid = true;
|
|
} else {
|
|
$namevalid = self::email('info@' . $matches['name']);
|
|
}
|
|
return $datevalid && $namevalid;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate a number
|
|
*
|
|
* @param string $number Number to validate
|
|
* @param array $options array where:
|
|
* 'decimal' is the decimal char or false when decimal
|
|
* not allowed.
|
|
* i.e. ',.' to allow both ',' and '.'
|
|
* 'dec_prec' Number of allowed decimals
|
|
* 'min' minimum value
|
|
* 'max' maximum value
|
|
*
|
|
* @return boolean true if valid number, false if not
|
|
*
|
|
* @access public
|
|
*/
|
|
function number($number, $options = array())
|
|
{
|
|
$decimal = $dec_prec = $min = $max = null;
|
|
if (is_array($options)) {
|
|
extract($options);
|
|
}
|
|
|
|
$dec_prec = $dec_prec ? "{1,$dec_prec}" : '+';
|
|
$dec_regex = $decimal ? "[$decimal][0-9]$dec_prec" : '';
|
|
|
|
if (!preg_match("|^[-+]?\s*[0-9]+($dec_regex)?\$|", $number)) {
|
|
return false;
|
|
}
|
|
|
|
if ($decimal != '.') {
|
|
$number = strtr($number, $decimal, '.');
|
|
}
|
|
|
|
$number = (float)str_replace(' ', '', $number);
|
|
if ($min !== null && $min > $number) {
|
|
return false;
|
|
}
|
|
|
|
if ($max !== null && $max < $number) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Converting a string to UTF-7 (RFC 2152)
|
|
*
|
|
* @param string $string string to be converted
|
|
*
|
|
* @return string converted string
|
|
*
|
|
* @access private
|
|
*/
|
|
function __stringToUtf7($string)
|
|
{
|
|
$return = '';
|
|
$utf7 = array(
|
|
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
|
|
'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
|
|
'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
|
|
'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
|
|
's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2',
|
|
'3', '4', '5', '6', '7', '8', '9', '+', ','
|
|
);
|
|
|
|
|
|
$state = 0;
|
|
|
|
if (!empty($string)) {
|
|
$i = 0;
|
|
while ($i <= strlen($string)) {
|
|
$char = substr($string, $i, 1);
|
|
if ($state == 0) {
|
|
if ((ord($char) >= 0x7F) || (ord($char) <= 0x1F)) {
|
|
if ($char) {
|
|
$return .= '&';
|
|
}
|
|
$state = 1;
|
|
} elseif ($char == '&') {
|
|
$return .= '&-';
|
|
} else {
|
|
$return .= $char;
|
|
}
|
|
} elseif (($i == strlen($string) ||
|
|
!((ord($char) >= 0x7F)) || (ord($char) <= 0x1F))) {
|
|
if ($state != 1) {
|
|
if (ord($char) > 64) {
|
|
$return .= '';
|
|
} else {
|
|
$return .= $utf7[ord($char)];
|
|
}
|
|
}
|
|
$return .= '-';
|
|
$state = 0;
|
|
} else {
|
|
switch($state) {
|
|
case 1:
|
|
$return .= $utf7[ord($char) >> 2];
|
|
$residue = (ord($char) & 0x03) << 4;
|
|
$state = 2;
|
|
break;
|
|
case 2:
|
|
$return .= $utf7[$residue | (ord($char) >> 4)];
|
|
$residue = (ord($char) & 0x0F) << 2;
|
|
$state = 3;
|
|
break;
|
|
case 3:
|
|
$return .= $utf7[$residue | (ord($char) >> 6)];
|
|
$return .= $utf7[ord($char) & 0x3F];
|
|
$state = 1;
|
|
break;
|
|
}
|
|
}
|
|
$i++;
|
|
}
|
|
return $return;
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Validate an email according to full RFC822 (inclusive human readable part)
|
|
*
|
|
* @param string $email email to validate,
|
|
* will return the address for optional dns validation
|
|
* @param array $options email() options
|
|
*
|
|
* @return boolean true if valid email, false if not
|
|
*
|
|
* @access private
|
|
*/
|
|
function __emailRFC822(&$email, &$options)
|
|
{
|
|
static $address = null;
|
|
static $uncomment = null;
|
|
if (!$address) {
|
|
// atom = 1*<any CHAR except specials, SPACE and CTLs>
|
|
$atom = '[^][()<>@,;:\\".\s\000-\037\177-\377]+\s*';
|
|
// qtext = <any CHAR excepting <">, ; => may be folded
|
|
// "\" & CR, and including linear-white-space>
|
|
$qtext = '[^"\\\\\r]';
|
|
// quoted-pair = "\" CHAR ; may quote any char
|
|
$quoted_pair = '\\\\.';
|
|
// quoted-string = <"> *(qtext/quoted-pair) <">; Regular qtext or
|
|
// ; quoted chars.
|
|
$quoted_string = '"(?:' . $qtext . '|' . $quoted_pair . ')*"\s*';
|
|
// word = atom / quoted-string
|
|
$word = '(?:' . $atom . '|' . $quoted_string . ')';
|
|
// local-part = word *("." word) ; uninterpreted
|
|
// ; case-preserved
|
|
$local_part = $word . '(?:\.\s*' . $word . ')*';
|
|
// dtext = <any CHAR excluding "[", ; => may be folded
|
|
// "]", "\" & CR, & including linear-white-space>
|
|
$dtext = '[^][\\\\\r]';
|
|
// domain-literal = "[" *(dtext / quoted-pair) "]"
|
|
$domain_literal = '\[(?:' . $dtext . '|' . $quoted_pair . ')*\]\s*';
|
|
// sub-domain = domain-ref / domain-literal
|
|
// domain-ref = atom ; symbolic reference
|
|
$sub_domain = '(?:' . $atom . '|' . $domain_literal . ')';
|
|
// domain = sub-domain *("." sub-domain)
|
|
$domain = $sub_domain . '(?:\.\s*' . $sub_domain . ')*';
|
|
// addr-spec = local-part "@" domain ; global address
|
|
$addr_spec = $local_part . '@\s*' . $domain;
|
|
// route = 1#("@" domain) ":" ; path-relative
|
|
$route = '@' . $domain . '(?:,@\s*' . $domain . ')*:\s*';
|
|
// route-addr = "<" [route] addr-spec ">"
|
|
$route_addr = '<\s*(?:' . $route . ')?' . $addr_spec . '>\s*';
|
|
// phrase = 1*word ; Sequence of words
|
|
$phrase = $word . '+';
|
|
// mailbox = addr-spec ; simple address
|
|
// / phrase route-addr ; name & addr-spec
|
|
$mailbox = '(?:' . $addr_spec . '|' . $phrase . $route_addr . ')';
|
|
// group = phrase ":" [#mailbox] ";"
|
|
$group = $phrase . ':\s*(?:' . $mailbox . '(?:,\s*' . $mailbox . ')*)?;\s*';
|
|
// address = mailbox ; one addressee
|
|
// / group ; named list
|
|
$address = '/^\s*(?:' . $mailbox . '|' . $group . ')$/';
|
|
|
|
$uncomment =
|
|
'/((?:(?:\\\\"|[^("])*(?:' . $quoted_string .
|
|
')?)*)((?<!\\\\)\((?:(?2)|.)*?(?<!\\\\)\))/';
|
|
}
|
|
// strip comments
|
|
$email = preg_replace($uncomment, '$1 ', $email);
|
|
return preg_match($address, $email);
|
|
}
|
|
|
|
/**
|
|
* Full TLD Validation function
|
|
*
|
|
* This function is used to make a much more proficient validation
|
|
* against all types of official domain names.
|
|
*
|
|
* @param string $email The email address to check.
|
|
* @param array $options The options for validation
|
|
*
|
|
* @access protected
|
|
*
|
|
* @return bool True if validating succeeds
|
|
*/
|
|
function _fullTLDValidation($email, $options)
|
|
{
|
|
$validate = array();
|
|
if(!empty($options["VALIDATE_ITLD_EMAILS"])) array_push($validate, 'itld');
|
|
if(!empty($options["VALIDATE_GTLD_EMAILS"])) array_push($validate, 'gtld');
|
|
if(!empty($options["VALIDATE_CCTLD_EMAILS"])) array_push($validate, 'cctld');
|
|
|
|
$self = new Validate;
|
|
|
|
$toValidate = array();
|
|
|
|
foreach ($validate as $valid) {
|
|
$tmpVar = '_' . (string)$valid;
|
|
|
|
$toValidate[$valid] = $self->{$tmpVar};
|
|
}
|
|
|
|
$e = $self->executeFullEmailValidation($email, $toValidate);
|
|
|
|
return $e;
|
|
}
|
|
|
|
/**
|
|
* Execute the validation
|
|
*
|
|
* This function will execute the full email vs tld
|
|
* validation using an array of tlds passed to it.
|
|
*
|
|
* @param string $email The email to validate.
|
|
* @param array $arrayOfTLDs The array of the TLDs to validate
|
|
*
|
|
* @access public
|
|
*
|
|
* @return true or false (Depending on if it validates or if it does not)
|
|
*/
|
|
function executeFullEmailValidation($email, $arrayOfTLDs)
|
|
{
|
|
$emailEnding = explode('.', $email);
|
|
$emailEnding = $emailEnding[count($emailEnding)-1];
|
|
foreach ($arrayOfTLDs as $validator => $keys) {
|
|
if (in_array($emailEnding, $keys)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Validate an email
|
|
*
|
|
* @param string $email email to validate
|
|
* @param mixed boolean (BC) $check_domain Check or not if the domain exists
|
|
* array $options associative array of options
|
|
* 'check_domain' boolean Check or not if the domain exists
|
|
* 'use_rfc822' boolean Apply the full RFC822 grammar
|
|
*
|
|
* Ex.
|
|
* $options = array(
|
|
* 'check_domain' => 'true',
|
|
* 'fullTLDValidation' => 'true',
|
|
* 'use_rfc822' => 'true',
|
|
* 'VALIDATE_GTLD_EMAILS' => 'true',
|
|
* 'VALIDATE_CCTLD_EMAILS' => 'true',
|
|
* 'VALIDATE_ITLD_EMAILS' => 'true',
|
|
* );
|
|
*
|
|
* @return boolean true if valid email, false if not
|
|
*
|
|
* @access public
|
|
*/
|
|
function email($email, $options = null)
|
|
{
|
|
$check_domain = false;
|
|
$use_rfc822 = false;
|
|
if (is_bool($options)) {
|
|
$check_domain = $options;
|
|
} elseif (is_array($options)) {
|
|
extract($options);
|
|
}
|
|
|
|
/**
|
|
* Check for IDN usage so we can encode the domain as Punycode
|
|
* before continuing.
|
|
*/
|
|
$hasIDNA = false;
|
|
|
|
if (@include_once('Net/IDNA.php')) {
|
|
$hasIDNA = true;
|
|
}
|
|
|
|
if ($hasIDNA === true) {
|
|
if (strpos($email, '@') !== false) {
|
|
list($name, $domain) = explode('@', $email, 2);
|
|
|
|
// Check if the domain contains characters > 127 which means
|
|
// it's an idn domain name.
|
|
$chars = count_chars($domain, 1);
|
|
if (!empty($chars) && max(array_keys($chars)) > 127) {
|
|
$idna = Net_IDNA::singleton();
|
|
$domain = $idna->encode($domain);
|
|
}
|
|
|
|
$email = "$name@$domain";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @todo Fix bug here.. even if it passes this, it won't be passing
|
|
* The regular expression below
|
|
*/
|
|
if (isset($fullTLDValidation)) {
|
|
//$valid = Validate::_fullTLDValidation($email, $fullTLDValidation);
|
|
$valid = Validate::_fullTLDValidation($email, $options);
|
|
|
|
if (!$valid) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// the base regexp for address
|
|
$regex = '&^(?: # recipient:
|
|
("\s*(?:[^"\f\n\r\t\v\b\s]+\s*)+")| #1 quoted name
|
|
([-\w!\#\$%\&\'*+~/^`|{}]+(?:\.[-\w!\#\$%\&\'*+~/^`|{}]+)*)) #2 OR dot-atom
|
|
@(((\[)? #3 domain, 4 as IPv4, 5 optionally bracketed
|
|
(?:(?:(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:[0-1]?[0-9]?[0-9]))\.){3}
|
|
(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:[0-1]?[0-9]?[0-9]))))(?(5)\])|
|
|
((?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)*[a-z0-9](?:[-a-z0-9]*[a-z0-9])?) #6 domain as hostname
|
|
\.((?:([^- ])[-a-z]*[-a-z]))) #7 TLD
|
|
$&xi';
|
|
|
|
//checks if exists the domain (MX or A)
|
|
if ($use_rfc822? Validate::__emailRFC822($email, $options) :
|
|
preg_match($regex, $email)) {
|
|
if ($check_domain && function_exists('checkdnsrr')) {
|
|
list ($account, $domain) = explode('@', $email);
|
|
if (checkdnsrr($domain, 'MX') || checkdnsrr($domain, 'A')) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Validate a string using the given format 'format'
|
|
*
|
|
* @param string $string String to validate
|
|
* @param array $options Options array where:
|
|
* 'format' is the format of the string
|
|
* Ex:VALIDATE_NUM . VALIDATE_ALPHA (see constants)
|
|
* 'min_length' minimum length
|
|
* 'max_length' maximum length
|
|
*
|
|
* @return boolean true if valid string, false if not
|
|
*
|
|
* @access public
|
|
*/
|
|
function string($string, $options)
|
|
{
|
|
$format = null;
|
|
$min_length = 0;
|
|
$max_length = 0;
|
|
|
|
if (is_array($options)) {
|
|
extract($options);
|
|
}
|
|
|
|
if ($format && !preg_match("|^[$format]*\$|s", $string)) {
|
|
return false;
|
|
}
|
|
|
|
if ($min_length && strlen($string) < $min_length) {
|
|
return false;
|
|
}
|
|
|
|
if ($max_length && strlen($string) > $max_length) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Validate an URI (RFC2396)
|
|
* This function will validate 'foobarstring' by default, to get it to validate
|
|
* only http, https, ftp and such you have to pass it in the allowed_schemes
|
|
* option, like this:
|
|
* <code>
|
|
* $options = array('allowed_schemes' => array('http', 'https', 'ftp'))
|
|
* var_dump(Validate::uri('http://www.example.org', $options));
|
|
* </code>
|
|
*
|
|
* NOTE 1: The rfc2396 normally allows middle '-' in the top domain
|
|
* e.g. http://example.co-m should be valid
|
|
* However, as '-' is not used in any known TLD, it is invalid
|
|
* NOTE 2: As double shlashes // are allowed in the path part, only full URIs
|
|
* including an authority can be valid, no relative URIs
|
|
* the // are mandatory (optionally preceeded by the 'sheme:' )
|
|
* NOTE 3: the full complience to rfc2396 is not achieved by default
|
|
* the characters ';/?:@$,' will not be accepted in the query part
|
|
* if not urlencoded, refer to the option "strict'"
|
|
*
|
|
* @param string $url URI to validate
|
|
* @param array $options Options used by the validation method.
|
|
* key => type
|
|
* 'domain_check' => boolean
|
|
* Whether to check the DNS entry or not
|
|
* 'allowed_schemes' => array, list of protocols
|
|
* List of allowed schemes ('http',
|
|
* 'ssh+svn', 'mms')
|
|
* 'strict' => string the refused chars
|
|
* in query and fragment parts
|
|
* default: ';/?:@$,'
|
|
* empty: accept all rfc2396 foreseen chars
|
|
*
|
|
* @return boolean true if valid uri, false if not
|
|
*
|
|
* @access public
|
|
*/
|
|
function uri($url, $options = null)
|
|
{
|
|
$strict = ';/?:@$,';
|
|
$domain_check = false;
|
|
$allowed_schemes = null;
|
|
if (is_array($options)) {
|
|
extract($options);
|
|
}
|
|
if (is_array($allowed_schemes) &&
|
|
in_array("tag", $allowed_schemes)
|
|
) {
|
|
if (strpos($url, "tag:") === 0) {
|
|
return self::__uriRFC4151($url);
|
|
}
|
|
}
|
|
|
|
if (preg_match(
|
|
'&^(?:([a-z][-+.a-z0-9]*):)? # 1. scheme
|
|
(?:// # authority start
|
|
(?:((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();:\&=+$,])*)@)? # 2. authority-userinfo
|
|
(?:((?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)*[a-z](?:[a-z0-9]+)?\.?) # 3. authority-hostname OR
|
|
|([0-9]{1,3}(?:\.[0-9]{1,3}){3})) # 4. authority-ipv4
|
|
(?::([0-9]*))?) # 5. authority-port
|
|
((?:/(?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'():@\&=+$,;])*)*/?)? # 6. path
|
|
(?:\?([^#]*))? # 7. query
|
|
(?:\#((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();/?:@\&=+$,])*))? # 8. fragment
|
|
$&xi', $url, $matches)) {
|
|
$scheme = isset($matches[1]) ? $matches[1] : '';
|
|
$authority = isset($matches[3]) ? $matches[3] : '' ;
|
|
if (is_array($allowed_schemes) &&
|
|
!in_array($scheme, $allowed_schemes)
|
|
) {
|
|
return false;
|
|
}
|
|
if (!empty($matches[4])) {
|
|
$parts = explode('.', $matches[4]);
|
|
foreach ($parts as $part) {
|
|
if ($part > 255) {
|
|
return false;
|
|
}
|
|
}
|
|
} elseif ($domain_check && function_exists('checkdnsrr')) {
|
|
if (!checkdnsrr($authority, 'A')) {
|
|
return false;
|
|
}
|
|
}
|
|
if ($strict) {
|
|
$strict = '#[' . preg_quote($strict, '#') . ']#';
|
|
if ((!empty($matches[7]) && preg_match($strict, $matches[7]))
|
|
|| (!empty($matches[8]) && preg_match($strict, $matches[8]))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Validate date and times. Note that this method need the Date_Calc class
|
|
*
|
|
* @param string $date Date to validate
|
|
* @param array $options array options where :
|
|
* 'format' The format of the date (%d-%m-%Y)
|
|
* or rfc822_compliant
|
|
* 'min' The date has to be greater
|
|
* than this array($day, $month, $year)
|
|
* or PEAR::Date object
|
|
* 'max' The date has to be smaller than
|
|
* this array($day, $month, $year)
|
|
* or PEAR::Date object
|
|
*
|
|
* @return boolean true if valid date/time, false if not
|
|
*
|
|
* @access public
|
|
*/
|
|
function date($date, $options)
|
|
{
|
|
$max = false;
|
|
$min = false;
|
|
$format = '';
|
|
|
|
if (is_array($options)) {
|
|
extract($options);
|
|
}
|
|
|
|
if (strtolower($format) == 'rfc822_compliant') {
|
|
$preg = '&^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),) \s+
|
|
(?:(\d{2})?) \s+
|
|
(?:(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)?) \s+
|
|
(?:(\d{2}(\d{2})?)?) \s+
|
|
(?:(\d{2}?)):(?:(\d{2}?))(:(?:(\d{2}?)))? \s+
|
|
(?:[+-]\d{4}|UT|GMT|EST|EDT|CST|CDT|MST|MDT|PST|PDT|[A-IK-Za-ik-z])$&xi';
|
|
|
|
if (!preg_match($preg, $date, $matches)) {
|
|
return false;
|
|
}
|
|
|
|
$year = (int)$matches[4];
|
|
$months = array('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
|
|
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec');
|
|
$month = array_keys($months, $matches[3]);
|
|
$month = (int)$month[0]+1;
|
|
$day = (int)$matches[2];
|
|
$weekday = $matches[1];
|
|
$hour = (int)$matches[6];
|
|
$minute = (int)$matches[7];
|
|
isset($matches[9]) ? $second = (int)$matches[9] : $second = 0;
|
|
|
|
if ((strlen($year) != 4) ||
|
|
($day > 31 || $day < 1)||
|
|
($hour > 23) ||
|
|
($minute > 59) ||
|
|
($second > 59)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
$date_len = strlen($format);
|
|
for ($i = 0; $i < $date_len; $i++) {
|
|
$c = $format{$i};
|
|
if ($c == '%') {
|
|
$next = $format{$i + 1};
|
|
switch ($next) {
|
|
case 'j':
|
|
case 'd':
|
|
if ($next == 'j') {
|
|
$day = (int)Validate::_substr($date, 1, 2);
|
|
} else {
|
|
$day = (int)Validate::_substr($date, 0, 2);
|
|
}
|
|
if ($day < 1 || $day > 31) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 'm':
|
|
case 'n':
|
|
if ($next == 'm') {
|
|
$month = (int)Validate::_substr($date, 0, 2);
|
|
} else {
|
|
$month = (int)Validate::_substr($date, 1, 2);
|
|
}
|
|
if ($month < 1 || $month > 12) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 'Y':
|
|
case 'y':
|
|
if ($next == 'Y') {
|
|
$year = Validate::_substr($date, 4);
|
|
$year = (int)$year?$year:'';
|
|
} else {
|
|
$year = (int)(substr(date('Y'), 0, 2) .
|
|
Validate::_substr($date, 2));
|
|
}
|
|
if (strlen($year) != 4 || $year < 0 || $year > 9999) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 'g':
|
|
case 'h':
|
|
if ($next == 'g') {
|
|
$hour = Validate::_substr($date, 1, 2);
|
|
} else {
|
|
$hour = Validate::_substr($date, 2);
|
|
}
|
|
if (!preg_match('/^\d+$/', $hour) || $hour < 0 || $hour > 12) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 'G':
|
|
case 'H':
|
|
if ($next == 'G') {
|
|
$hour = Validate::_substr($date, 1, 2);
|
|
} else {
|
|
$hour = Validate::_substr($date, 2);
|
|
}
|
|
if (!preg_match('/^\d+$/', $hour) || $hour < 0 || $hour > 24) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 's':
|
|
case 'i':
|
|
$t = Validate::_substr($date, 2);
|
|
if (!preg_match('/^\d+$/', $t) || $t < 0 || $t > 59) {
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
trigger_error("Not supported char `$next' after % in offset " . ($i+2), E_USER_WARNING);
|
|
}
|
|
$i++;
|
|
} else {
|
|
//literal
|
|
if (Validate::_substr($date, 1) != $c) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// there is remaing data, we don't want it
|
|
if (strlen($date) && (strtolower($format) != 'rfc822_compliant')) {
|
|
return false;
|
|
}
|
|
|
|
if (isset($day) && isset($month) && isset($year)) {
|
|
if (!checkdate($month, $day, $year)) {
|
|
return false;
|
|
}
|
|
|
|
if (strtolower($format) == 'rfc822_compliant') {
|
|
if ($weekday != date("D", mktime(0, 0, 0, $month, $day, $year))) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ($min) {
|
|
include_once 'Date/Calc.php';
|
|
if (is_a($min, 'Date') &&
|
|
(Date_Calc::compareDates($day, $month, $year,
|
|
$min->getDay(), $min->getMonth(), $min->getYear()) < 0)
|
|
) {
|
|
return false;
|
|
} elseif (is_array($min) &&
|
|
(Date_Calc::compareDates($day, $month, $year,
|
|
$min[0], $min[1], $min[2]) < 0)
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ($max) {
|
|
include_once 'Date/Calc.php';
|
|
if (is_a($max, 'Date') &&
|
|
(Date_Calc::compareDates($day, $month, $year,
|
|
$max->getDay(), $max->getMonth(), $max->getYear()) > 0)
|
|
) {
|
|
return false;
|
|
} elseif (is_array($max) &&
|
|
(Date_Calc::compareDates($day, $month, $year,
|
|
$max[0], $max[1], $max[2]) > 0)
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Substr
|
|
*
|
|
* @param string &$date Date
|
|
* @param string $num Length
|
|
* @param string $opt Unknown
|
|
*
|
|
* @access private
|
|
* @return string
|
|
*/
|
|
function _substr(&$date, $num, $opt = false)
|
|
{
|
|
if ($opt && strlen($date) >= $opt && preg_match('/^[0-9]{'.$opt.'}/', $date, $m)) {
|
|
$ret = $m[0];
|
|
} else {
|
|
$ret = substr($date, 0, $num);
|
|
}
|
|
$date = substr($date, strlen($ret));
|
|
return $ret;
|
|
}
|
|
|
|
function _modf($val, $div)
|
|
{
|
|
if (function_exists('bcmod')) {
|
|
return bcmod($val, $div);
|
|
} elseif (function_exists('fmod')) {
|
|
return fmod($val, $div);
|
|
}
|
|
$r = $val / $div;
|
|
$i = intval($r);
|
|
return intval($val - $i * $div + .1);
|
|
}
|
|
|
|
/**
|
|
* Calculates sum of product of number digits with weights
|
|
*
|
|
* @param string $number number string
|
|
* @param array $weights reference to array of weights
|
|
*
|
|
* @access protected
|
|
*
|
|
* @return int returns product of number digits with weights
|
|
*/
|
|
function _multWeights($number, &$weights)
|
|
{
|
|
if (!is_array($weights)) {
|
|
return -1;
|
|
}
|
|
$sum = 0;
|
|
|
|
$count = min(count($weights), strlen($number));
|
|
if ($count == 0) { // empty string or weights array
|
|
return -1;
|
|
}
|
|
for ($i = 0; $i < $count; ++$i) {
|
|
$sum += intval(substr($number, $i, 1)) * $weights[$i];
|
|
}
|
|
|
|
return $sum;
|
|
}
|
|
|
|
/**
|
|
* Calculates control digit for a given number
|
|
*
|
|
* @param string $number number string
|
|
* @param array $weights reference to array of weights
|
|
* @param int $modulo (optionsl) number
|
|
* @param int $subtract (optional) number
|
|
* @param bool $allow_high (optional) true if function can return number higher than 10
|
|
*
|
|
* @access protected
|
|
*
|
|
* @return int -1 calculated control number is returned
|
|
*/
|
|
function _getControlNumber($number, &$weights, $modulo = 10, $subtract = 0, $allow_high = false)
|
|
{
|
|
// calc sum
|
|
$sum = Validate::_multWeights($number, $weights);
|
|
if ($sum == -1) {
|
|
return -1;
|
|
}
|
|
$mod = Validate::_modf($sum, $modulo); // calculate control digit
|
|
|
|
if ($subtract > $mod && $mod > 0) {
|
|
$mod = $subtract - $mod;
|
|
}
|
|
if ($allow_high === false) {
|
|
$mod %= 10; // change 10 to zero
|
|
}
|
|
return $mod;
|
|
}
|
|
|
|
/**
|
|
* Validates a number
|
|
*
|
|
* @param string $number number to validate
|
|
* @param array $weights reference to array of weights
|
|
* @param int $modulo (optional) number
|
|
* @param int $subtract (optional) number
|
|
*
|
|
* @access protected
|
|
*
|
|
* @return bool true if valid, false if not
|
|
*/
|
|
function _checkControlNumber($number, &$weights, $modulo = 10, $subtract = 0)
|
|
{
|
|
if (strlen($number) < count($weights)) {
|
|
return false;
|
|
}
|
|
$target_digit = substr($number, count($weights), 1);
|
|
$control_digit = Validate::_getControlNumber($number, $weights, $modulo, $subtract, $modulo > 10);
|
|
|
|
if ($control_digit == -1) {
|
|
return false;
|
|
}
|
|
if ($target_digit === 'X' && $control_digit == 10) {
|
|
return true;
|
|
}
|
|
if ($control_digit != $target_digit) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Bulk data validation for data introduced in the form of an
|
|
* assoc array in the form $var_name => $value.
|
|
* Can be used on any of Validate subpackages
|
|
*
|
|
* @param array $data Ex: array('name' => 'toto', 'email' => 'toto@thing.info');
|
|
* @param array $val_type Contains the validation type and all parameters used in.
|
|
* 'val_type' is not optional
|
|
* others validations properties must have the same name as the function
|
|
* parameters.
|
|
* Ex: array('toto'=>array('type'=>'string','format'='toto@thing.info','min_length'=>5));
|
|
* @param boolean $remove if set, the elements not listed in data will be removed
|
|
*
|
|
* @return array value name => true|false the value name comes from the data key
|
|
*
|
|
* @access public
|
|
*/
|
|
function multiple(&$data, &$val_type, $remove = false)
|
|
{
|
|
$keys = array_keys($data);
|
|
$valid = array();
|
|
|
|
foreach ($keys as $var_name) {
|
|
if (!isset($val_type[$var_name])) {
|
|
if ($remove) {
|
|
unset($data[$var_name]);
|
|
}
|
|
continue;
|
|
}
|
|
$opt = $val_type[$var_name];
|
|
$methods = get_class_methods('Validate');
|
|
$val2check = $data[$var_name];
|
|
// core validation method
|
|
if (in_array(strtolower($opt['type']), $methods)) {
|
|
//$opt[$opt['type']] = $data[$var_name];
|
|
$method = $opt['type'];
|
|
unset($opt['type']);
|
|
|
|
if (sizeof($opt) == 1 && is_array(reset($opt))) {
|
|
$opt = array_pop($opt);
|
|
}
|
|
$valid[$var_name] = call_user_func(array('Validate', $method), $val2check, $opt);
|
|
|
|
/**
|
|
* external validation method in the form:
|
|
* "<class name><underscore><method name>"
|
|
* Ex: us_ssn will include class Validate/US.php and call method ssn()
|
|
*/
|
|
} elseif (strpos($opt['type'], '_') !== false) {
|
|
$validateType = explode('_', $opt['type']);
|
|
$method = array_pop($validateType);
|
|
$class = implode('_', $validateType);
|
|
$classPath = str_replace('_', DIRECTORY_SEPARATOR, $class);
|
|
$class = 'Validate_' . $class;
|
|
if (!@include_once "Validate/$classPath.php") {
|
|
trigger_error("$class isn't installed or you may have some permissoin issues", E_USER_ERROR);
|
|
}
|
|
|
|
$ce = substr(phpversion(), 0, 1) > 4 ?
|
|
class_exists($class, false) : class_exists($class);
|
|
if (!$ce ||
|
|
!in_array($method, get_class_methods($class))
|
|
) {
|
|
trigger_error("Invalid validation type $class::$method",
|
|
E_USER_WARNING);
|
|
continue;
|
|
}
|
|
unset($opt['type']);
|
|
if (sizeof($opt) == 1) {
|
|
$opt = array_pop($opt);
|
|
}
|
|
$valid[$var_name] = call_user_func(array($class, $method),
|
|
$data[$var_name], $opt);
|
|
} else {
|
|
trigger_error("Invalid validation type {$opt['type']}",
|
|
E_USER_WARNING);
|
|
}
|
|
}
|
|
return $valid;
|
|
}
|
|
}
|
|
|