]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - extlib/Validate.php
can't repeat your own notice posted through realtime
[quix0rs-gnu-social.git] / extlib / Validate.php
1 <?php
2 /**
3  * Validation class
4  *
5  * Copyright (c) 1997-2006 Pierre-Alain Joye,Tomas V.V.Cox, Amir Saied  
6  *
7  * This source file is subject to the New BSD license, That is bundled  
8  * with this package in the file LICENSE, and is available through      
9  * the world-wide-web at                                                
10  * http://www.opensource.org/licenses/bsd-license.php                   
11  * If you did not receive a copy of the new BSDlicense and are unable   
12  * to obtain it through the world-wide-web, please send a note to       
13  * pajoye@php.net so we can mail you a copy immediately.                
14  *
15  * Author: Tomas V.V.Cox  <cox@idecnet.com>                             
16  *         Pierre-Alain Joye <pajoye@php.net>                           
17  *         Amir Mohammad Saied <amir@php.net>                           
18  *
19  *
20  * Package to validate various datas. It includes :
21  *   - numbers (min/max, decimal or not)
22  *   - email (syntax, domain check)
23  *   - string (predifined type alpha upper and/or lowercase, numeric,...)
24  *   - date (min, max, rfc822 compliant)
25  *   - uri (RFC2396)
26  *   - possibility valid multiple data with a single method call (::multiple)
27  *
28  * @category   Validate
29  * @package    Validate
30  * @author     Tomas V.V.Cox <cox@idecnet.com>
31  * @author     Pierre-Alain Joye <pajoye@php.net>
32  * @author     Amir Mohammad Saied <amir@php.net>
33  * @copyright  1997-2006 Pierre-Alain Joye,Tomas V.V.Cox,Amir Mohammad Saied
34  * @license    http://www.opensource.org/licenses/bsd-license.php  New BSD License
35  * @version    CVS: $Id: Validate.php,v 1.134 2009/01/28 12:27:33 davidc Exp $
36  * @link       http://pear.php.net/package/Validate
37  */
38
39 /**
40  * Methods for common data validations
41  */
42 define('VALIDATE_NUM',          '0-9');
43 define('VALIDATE_SPACE',        '\s');
44 define('VALIDATE_ALPHA_LOWER',  'a-z');
45 define('VALIDATE_ALPHA_UPPER',  'A-Z');
46 define('VALIDATE_ALPHA',        VALIDATE_ALPHA_LOWER . VALIDATE_ALPHA_UPPER);
47 define('VALIDATE_EALPHA_LOWER', VALIDATE_ALPHA_LOWER . 'áéíóúýàèìòùäëïöüÿâêîôûãñõ¨åæç½ðøþß');
48 define('VALIDATE_EALPHA_UPPER', VALIDATE_ALPHA_UPPER . 'ÁÉÍÓÚÝÀÈÌÒÙÄËÏÖܾÂÊÎÔÛÃÑÕ¦ÅÆǼÐØÞ');
49 define('VALIDATE_EALPHA',       VALIDATE_EALPHA_LOWER . VALIDATE_EALPHA_UPPER);
50 define('VALIDATE_PUNCTUATION',  VALIDATE_SPACE . '\.,;\:&"\'\?\!\(\)');
51 define('VALIDATE_NAME',         VALIDATE_EALPHA . VALIDATE_SPACE . "'" . "-");
52 define('VALIDATE_STREET',       VALIDATE_NUM . VALIDATE_NAME . "/\\ºª\.");
53
54 define('VALIDATE_ITLD_EMAILS',  1);
55 define('VALIDATE_GTLD_EMAILS',  2);
56 define('VALIDATE_CCTLD_EMAILS', 4);
57 define('VALIDATE_ALL_EMAILS',   8);
58
59 /**
60  * Validation class
61  *
62  * Package to validate various datas. It includes :
63  *   - numbers (min/max, decimal or not)
64  *   - email (syntax, domain check)
65  *   - string (predifined type alpha upper and/or lowercase, numeric,...)
66  *   - date (min, max)
67  *   - uri (RFC2396)
68  *   - possibility valid multiple data with a single method call (::multiple)
69  *
70  * @category  Validate
71  * @package   Validate
72  * @author    Tomas V.V.Cox <cox@idecnet.com>
73  * @author    Pierre-Alain Joye <pajoye@php.net>
74  * @author    Amir Mohammad Saied <amir@php.net>
75  * @copyright 1997-2006 Pierre-Alain Joye,Tomas V.V.Cox,Amir Mohammad Saied
76  * @license   http://www.opensource.org/licenses/bsd-license.php  New BSD License
77  * @version   Release: @package_version@
78  * @link      http://pear.php.net/package/Validate
79  */
80 class Validate
81 {
82     /**
83      * International Top-Level Domain
84      *
85      * This is an array of the known international
86      * top-level domain names.
87      *
88      * @access protected
89      * @var    array     $_iTld (International top-level domains)
90      */
91     var $_itld = array(
92         'arpa',
93         'root',
94     );
95
96     /**
97      * Generic top-level domain
98      *
99      * This is an array of the official
100      * generic top-level domains.
101      *
102      * @access protected
103      * @var    array     $_gTld (Generic top-level domains)
104      */
105     var $_gtld = array(
106         'aero',
107         'biz',
108         'cat',
109         'com',
110         'coop',
111         'edu',
112         'gov',
113         'info',
114         'int',
115         'jobs',
116         'mil',
117         'mobi',
118         'museum',
119         'name',
120         'net',
121         'org',
122         'pro',
123         'travel',
124         'asia',
125         'post',
126         'tel',
127         'geo',
128     );
129
130     /**
131      * Country code top-level domains
132      *
133      * This is an array of the official country
134      * codes top-level domains
135      *
136      * @access protected
137      * @var    array     $_ccTld (Country Code Top-Level Domain)
138      */
139     var $_cctld = array(
140         'ac',
141         'ad','ae','af','ag',
142         'ai','al','am','an',
143         'ao','aq','ar','as',
144         'at','au','aw','ax',
145         'az','ba','bb','bd',
146         'be','bf','bg','bh',
147         'bi','bj','bm','bn',
148         'bo','br','bs','bt',
149         'bu','bv','bw','by',
150         'bz','ca','cc','cd',
151         'cf','cg','ch','ci',
152         'ck','cl','cm','cn',
153         'co','cr','cs','cu',
154         'cv','cx','cy','cz',
155         'de','dj','dk','dm',
156         'do','dz','ec','ee',
157         'eg','eh','er','es',
158         'et','eu','fi','fj',
159         'fk','fm','fo','fr',
160         'ga','gb','gd','ge',
161         'gf','gg','gh','gi',
162         'gl','gm','gn','gp',
163         'gq','gr','gs','gt',
164         'gu','gw','gy','hk',
165         'hm','hn','hr','ht',
166         'hu','id','ie','il',
167         'im','in','io','iq',
168         'ir','is','it','je',
169         'jm','jo','jp','ke',
170         'kg','kh','ki','km',
171         'kn','kp','kr','kw',
172         'ky','kz','la','lb',
173         'lc','li','lk','lr',
174         'ls','lt','lu','lv',
175         'ly','ma','mc','md',
176         'me','mg','mh','mk',
177         'ml','mm','mn','mo',
178         'mp','mq','mr','ms',
179         'mt','mu','mv','mw',
180         'mx','my','mz','na',
181         'nc','ne','nf','ng',
182         'ni','nl','no','np',
183         'nr','nu','nz','om',
184         'pa','pe','pf','pg',
185         'ph','pk','pl','pm',
186         'pn','pr','ps','pt',
187         'pw','py','qa','re',
188         'ro','rs','ru','rw',
189         'sa','sb','sc','sd',
190         'se','sg','sh','si',
191         'sj','sk','sl','sm',
192         'sn','so','sr','st',
193         'su','sv','sy','sz',
194         'tc','td','tf','tg',
195         'th','tj','tk','tl',
196         'tm','tn','to','tp',
197         'tr','tt','tv','tw',
198         'tz','ua','ug','uk',
199         'us','uy','uz','va',
200         'vc','ve','vg','vi',
201         'vn','vu','wf','ws',
202         'ye','yt','yu','za',
203         'zm','zw',
204     );
205
206     /**
207      * Validate a tag URI (RFC4151)
208      *
209      * @param string $uri tag URI to validate
210      *
211      * @return boolean true if valid tag URI, false if not
212      *
213      * @access private
214      */
215     function __uriRFC4151($uri)
216     {
217         $datevalid = false;
218         if (preg_match(
219             '/^tag:(?<name>.*),(?<date>\d{4}-?\d{0,2}-?\d{0,2}):(?<specific>.*)(.*:)*$/', $uri, $matches)) {
220             $date  = $matches['date'];
221             $date6 = strtotime($date);
222             if ((strlen($date) == 4) && $date <= date('Y')) {
223                 $datevalid = true;
224             } elseif ((strlen($date) == 7) && ($date6 < strtotime("now"))) {
225                 $datevalid = true;
226             } elseif ((strlen($date) == 10) && ($date6 < strtotime("now"))) {
227                 $datevalid = true;
228             }
229             if (self::email($matches['name'])) {
230                 $namevalid = true;
231             } else {
232                 $namevalid = self::email('info@' . $matches['name']);
233             }
234             return $datevalid && $namevalid;
235         } else {
236             return false;
237         }
238     }
239
240     /**
241      * Validate a number
242      *
243      * @param string $number  Number to validate
244      * @param array  $options array where:
245      *                          'decimal'  is the decimal char or false when decimal
246      *                                     not allowed.
247      *                                     i.e. ',.' to allow both ',' and '.'
248      *                          'dec_prec' Number of allowed decimals
249      *                          'min'      minimum value
250      *                          'max'      maximum value
251      *
252      * @return boolean true if valid number, false if not
253      *
254      * @access public
255      */
256     function number($number, $options = array())
257     {
258         $decimal = $dec_prec = $min = $max = null;
259         if (is_array($options)) {
260             extract($options);
261         }
262
263         $dec_prec  = $dec_prec ? "{1,$dec_prec}" : '+';
264         $dec_regex = $decimal  ? "[$decimal][0-9]$dec_prec" : '';
265
266         if (!preg_match("|^[-+]?\s*[0-9]+($dec_regex)?\$|", $number)) {
267             return false;
268         }
269
270         if ($decimal != '.') {
271             $number = strtr($number, $decimal, '.');
272         }
273
274         $number = (float)str_replace(' ', '', $number);
275         if ($min !== null && $min > $number) {
276             return false;
277         }
278
279         if ($max !== null && $max < $number) {
280             return false;
281         }
282         return true;
283     }
284
285     /**
286      * Converting a string to UTF-7 (RFC 2152)
287      *
288      * @param string $string string to be converted
289      *
290      * @return  string  converted string
291      *
292      * @access  private
293      */
294     function __stringToUtf7($string)
295     {
296         $return = '';
297         $utf7   = array(
298                         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
299                         'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
300                         'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
301                         'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
302                         's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2',
303                         '3', '4', '5', '6', '7', '8', '9', '+', ','
304                     );
305
306
307         $state = 0;
308
309         if (!empty($string)) {
310             $i = 0;
311             while ($i <= strlen($string)) {
312                 $char = substr($string, $i, 1);
313                 if ($state == 0) {
314                     if ((ord($char) >= 0x7F) || (ord($char) <= 0x1F)) {
315                         if ($char) {
316                             $return .= '&';
317                         }
318                         $state = 1;
319                     } elseif ($char == '&') {
320                         $return .= '&-';
321                     } else {
322                         $return .= $char;
323                     }
324                 } elseif (($i == strlen($string) ||
325                             !((ord($char) >= 0x7F)) || (ord($char) <= 0x1F))) {
326                     if ($state != 1) {
327                         if (ord($char) > 64) {
328                             $return .= '';
329                         } else {
330                             $return .= $utf7[ord($char)];
331                         }
332                     }
333                     $return .= '-';
334                     $state   = 0;
335                 } else {
336                     switch($state) {
337                     case 1:
338                         $return .= $utf7[ord($char) >> 2];
339                         $residue = (ord($char) & 0x03) << 4;
340                         $state   = 2;
341                         break;
342                     case 2:
343                         $return .= $utf7[$residue | (ord($char) >> 4)];
344                         $residue = (ord($char) & 0x0F) << 2;
345                         $state   = 3;
346                         break;
347                     case 3:
348                         $return .= $utf7[$residue | (ord($char) >> 6)];
349                         $return .= $utf7[ord($char) & 0x3F];
350                         $state   = 1;
351                         break;
352                     }
353                 }
354                 $i++;
355             }
356             return $return;
357         }
358         return '';
359     }
360
361     /**
362      * Validate an email according to full RFC822 (inclusive human readable part)
363      *
364      * @param string $email   email to validate,
365      *                        will return the address for optional dns validation
366      * @param array  $options email() options
367      *
368      * @return boolean true if valid email, false if not
369      *
370      * @access private
371      */
372     function __emailRFC822(&$email, &$options)
373     {
374         static $address   = null;
375         static $uncomment = null;
376         if (!$address) {
377             // atom        =  1*<any CHAR except specials, SPACE and CTLs>
378             $atom = '[^][()<>@,;:\\".\s\000-\037\177-\377]+\s*';
379             // qtext       =  <any CHAR excepting <">,     ; => may be folded
380             //         "\" & CR, and including linear-white-space>
381             $qtext = '[^"\\\\\r]';
382             // quoted-pair =  "\" CHAR                     ; may quote any char
383             $quoted_pair = '\\\\.';
384             // quoted-string = <"> *(qtext/quoted-pair) <">; Regular qtext or
385             //                                             ;   quoted chars.
386             $quoted_string = '"(?:' . $qtext . '|' . $quoted_pair . ')*"\s*';
387             // word        =  atom / quoted-string
388             $word = '(?:' . $atom . '|' . $quoted_string . ')';
389             // local-part  =  word *("." word)             ; uninterpreted
390             //                                             ; case-preserved
391             $local_part = $word . '(?:\.\s*' . $word . ')*';
392             // dtext       =  <any CHAR excluding "[",     ; => may be folded
393             //         "]", "\" & CR, & including linear-white-space>
394             $dtext = '[^][\\\\\r]';
395             // domain-literal =  "[" *(dtext / quoted-pair) "]"
396             $domain_literal = '\[(?:' . $dtext . '|' . $quoted_pair . ')*\]\s*';
397             // sub-domain  =  domain-ref / domain-literal
398             // domain-ref  =  atom                         ; symbolic reference
399             $sub_domain = '(?:' . $atom . '|' . $domain_literal . ')';
400             // domain      =  sub-domain *("." sub-domain)
401             $domain = $sub_domain . '(?:\.\s*' . $sub_domain . ')*';
402             // addr-spec   =  local-part "@" domain        ; global address
403             $addr_spec = $local_part . '@\s*' . $domain;
404             // route       =  1#("@" domain) ":"           ; path-relative
405             $route = '@' . $domain . '(?:,@\s*' . $domain . ')*:\s*';
406             // route-addr  =  "<" [route] addr-spec ">"
407             $route_addr = '<\s*(?:' . $route . ')?' . $addr_spec . '>\s*';
408             // phrase      =  1*word                       ; Sequence of words
409             $phrase = $word  . '+';
410             // mailbox     =  addr-spec                    ; simple address
411             //             /  phrase route-addr            ; name & addr-spec
412             $mailbox = '(?:' . $addr_spec . '|' . $phrase . $route_addr . ')';
413             // group       =  phrase ":" [#mailbox] ";"
414             $group = $phrase . ':\s*(?:' . $mailbox . '(?:,\s*' . $mailbox . ')*)?;\s*';
415             //     address     =  mailbox                      ; one addressee
416             //                 /  group                        ; named list
417             $address = '/^\s*(?:' . $mailbox . '|' . $group . ')$/';
418
419             $uncomment =
420             '/((?:(?:\\\\"|[^("])*(?:' . $quoted_string .
421                                              ')?)*)((?<!\\\\)\((?:(?2)|.)*?(?<!\\\\)\))/';
422         }
423         // strip comments
424         $email = preg_replace($uncomment, '$1 ', $email);
425         return preg_match($address, $email);
426     }
427
428     /**
429      * Full TLD Validation function
430      *
431      * This function is used to make a much more proficient validation
432      * against all types of official domain names.
433      *
434      * @param string $email   The email address to check.
435      * @param array  $options The options for validation
436      *
437      * @access protected
438      *
439      * @return bool True if validating succeeds
440      */
441     function _fullTLDValidation($email, $options)
442     {
443         $validate = array();
444         if(!empty($options["VALIDATE_ITLD_EMAILS"])) array_push($validate, 'itld');
445         if(!empty($options["VALIDATE_GTLD_EMAILS"])) array_push($validate, 'gtld');
446         if(!empty($options["VALIDATE_CCTLD_EMAILS"])) array_push($validate, 'cctld');
447
448         $self = new Validate;
449
450         $toValidate = array();
451
452         foreach ($validate as $valid) {
453             $tmpVar = '_' . (string)$valid;
454
455             $toValidate[$valid] = $self->{$tmpVar};
456         }
457
458         $e = $self->executeFullEmailValidation($email, $toValidate);
459
460         return $e;
461     }
462     
463     /**
464      * Execute the validation
465      *
466      * This function will execute the full email vs tld
467      * validation using an array of tlds passed to it.
468      *
469      * @param string $email       The email to validate.
470      * @param array  $arrayOfTLDs The array of the TLDs to validate
471      *
472      * @access public
473      *
474      * @return true or false (Depending on if it validates or if it does not)
475      */
476     function executeFullEmailValidation($email, $arrayOfTLDs)
477     {
478         $emailEnding = explode('.', $email);
479         $emailEnding = $emailEnding[count($emailEnding)-1];
480         foreach ($arrayOfTLDs as $validator => $keys) {
481             if (in_array($emailEnding, $keys)) {
482                 return true;
483             }
484         }
485         return false;
486     }
487
488     /**
489      * Validate an email
490      *
491      * @param string $email  email to validate
492      * @param mixed  boolean (BC) $check_domain Check or not if the domain exists
493      *              array $options associative array of options
494      *              'check_domain' boolean Check or not if the domain exists
495      *              'use_rfc822' boolean Apply the full RFC822 grammar
496      *
497      * Ex.
498      *  $options = array(
499      *      'check_domain' => 'true',
500      *      'fullTLDValidation' => 'true',
501      *      'use_rfc822' => 'true',
502      *      'VALIDATE_GTLD_EMAILS' => 'true',
503      *      'VALIDATE_CCTLD_EMAILS' => 'true',
504      *      'VALIDATE_ITLD_EMAILS' => 'true',           
505      *      );
506      *
507      * @return boolean true if valid email, false if not
508      *
509      * @access public
510      */
511     function email($email, $options = null)
512     {
513         $check_domain = false;
514         $use_rfc822   = false;
515         if (is_bool($options)) {
516             $check_domain = $options;
517         } elseif (is_array($options)) {
518             extract($options);
519         }
520
521         /**
522          * Check for IDN usage so we can encode the domain as Punycode
523          * before continuing.
524          */
525         $hasIDNA = false;
526
527         if (@include_once('Net/IDNA.php')) {
528             $hasIDNA = true;
529         }
530
531         if ($hasIDNA === true) {
532             if (strpos($email, '@') !== false) {
533                 list($name, $domain) = explode('@', $email, 2);
534
535                 // Check if the domain contains characters > 127 which means 
536                 // it's an idn domain name.
537                 $chars = count_chars($domain, 1);
538                 if (!empty($chars) && max(array_keys($chars)) > 127) {
539                     $idna   =& Net_IDNA::singleton();
540                     $domain = $idna->encode($domain);
541                 }
542
543                 $email = "$name@$domain";
544             }
545         }
546         
547         /**
548          * @todo Fix bug here.. even if it passes this, it won't be passing
549          *       The regular expression below
550          */
551         if (isset($fullTLDValidation)) {
552             //$valid = Validate::_fullTLDValidation($email, $fullTLDValidation);
553             $valid = Validate::_fullTLDValidation($email, $options);
554
555             if (!$valid) {
556                 return false;
557             }
558         }
559
560         // the base regexp for address
561         $regex = '&^(?:                                               # recipient:
562          ("\s*(?:[^"\f\n\r\t\v\b\s]+\s*)+")|                          #1 quoted name
563          ([-\w!\#\$%\&\'*+~/^`|{}]+(?:\.[-\w!\#\$%\&\'*+~/^`|{}]+)*)) #2 OR dot-atom
564          @(((\[)?                     #3 domain, 4 as IPv4, 5 optionally bracketed
565          (?:(?:(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:[0-1]?[0-9]?[0-9]))\.){3}
566                (?:(?:25[0-5])|(?:2[0-4][0-9])|(?:[0-1]?[0-9]?[0-9]))))(?(5)\])|
567          ((?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)*[a-z0-9](?:[-a-z0-9]*[a-z0-9])?)  #6 domain as hostname
568          \.((?:([^- ])[-a-z]*[-a-z]))) #7 TLD 
569          $&xi';
570
571         //checks if exists the domain (MX or A)
572         if ($use_rfc822? Validate::__emailRFC822($email, $options) :
573                 preg_match($regex, $email)) {
574             if ($check_domain && function_exists('checkdnsrr')) {
575                 list ($account, $domain) = explode('@', $email);
576                 if (checkdnsrr($domain, 'MX') || checkdnsrr($domain, 'A')) {
577                     return true;
578                 }
579                 return false;
580             }
581             return true;
582         }
583         return false;
584     }
585
586     /**
587      * Validate a string using the given format 'format'
588      *
589      * @param string $string  String to validate
590      * @param array  $options Options array where:
591      *                          'format' is the format of the string
592      *                              Ex:VALIDATE_NUM . VALIDATE_ALPHA (see constants)
593      *                          'min_length' minimum length
594      *                          'max_length' maximum length
595      *
596      * @return boolean true if valid string, false if not
597      *
598      * @access public
599      */
600     function string($string, $options)
601     {
602         $format     = null;
603         $min_length = 0;
604         $max_length = 0;
605
606         if (is_array($options)) {
607             extract($options);
608         }
609
610         if ($format && !preg_match("|^[$format]*\$|s", $string)) {
611             return false;
612         }
613
614         if ($min_length && strlen($string) < $min_length) {
615             return false;
616         }
617
618         if ($max_length && strlen($string) > $max_length) {
619             return false;
620         }
621
622         return true;
623     }
624
625     /**
626      * Validate an URI (RFC2396)
627      * This function will validate 'foobarstring' by default, to get it to validate
628      * only http, https, ftp and such you have to pass it in the allowed_schemes
629      * option, like this:
630      * <code>
631      * $options = array('allowed_schemes' => array('http', 'https', 'ftp'))
632      * var_dump(Validate::uri('http://www.example.org', $options));
633      * </code>
634      *
635      * NOTE 1: The rfc2396 normally allows middle '-' in the top domain
636      *         e.g. http://example.co-m should be valid
637      *         However, as '-' is not used in any known TLD, it is invalid
638      * NOTE 2: As double shlashes // are allowed in the path part, only full URIs
639      *         including an authority can be valid, no relative URIs
640      *         the // are mandatory (optionally preceeded by the 'sheme:' )
641      * NOTE 3: the full complience to rfc2396 is not achieved by default
642      *         the characters ';/?:@$,' will not be accepted in the query part
643      *         if not urlencoded, refer to the option "strict'"
644      *
645      * @param string $url     URI to validate
646      * @param array  $options Options used by the validation method.
647      *                          key => type
648      *                          'domain_check' => boolean
649      *                              Whether to check the DNS entry or not
650      *                          'allowed_schemes' => array, list of protocols
651      *                              List of allowed schemes ('http',
652      *                              'ssh+svn', 'mms')
653      *                          'strict' => string the refused chars
654      *                              in query and fragment parts
655      *                              default: ';/?:@$,'
656      *                              empty: accept all rfc2396 foreseen chars
657      *
658      * @return boolean true if valid uri, false if not
659      *
660      * @access public
661      */
662     function uri($url, $options = null)
663     {
664         $strict = ';/?:@$,';
665         $domain_check = false;
666         $allowed_schemes = null;
667         if (is_array($options)) {
668             extract($options);
669         }
670         if (is_array($allowed_schemes) &&
671             in_array("tag", $allowed_schemes)
672         ) {
673             if (strpos($url, "tag:") === 0) {
674                 return self::__uriRFC4151($url);
675             }
676         }
677
678         if (preg_match(
679              '&^(?:([a-z][-+.a-z0-9]*):)?                             # 1. scheme
680               (?://                                                   # authority start
681               (?:((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();:\&=+$,])*)@)?    # 2. authority-userinfo
682               (?:((?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)*[a-z](?:[a-z0-9]+)?\.?)  # 3. authority-hostname OR
683               |([0-9]{1,3}(?:\.[0-9]{1,3}){3}))                       # 4. authority-ipv4
684               (?::([0-9]*))?)                                        # 5. authority-port
685               ((?:/(?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'():@\&=+$,;])*)*/?)? # 6. path
686               (?:\?([^#]*))?                                          # 7. query
687               (?:\#((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();/?:@\&=+$,])*))? # 8. fragment
688               $&xi', $url, $matches)) {
689             $scheme = isset($matches[1]) ? $matches[1] : '';
690             $authority = isset($matches[3]) ? $matches[3] : '' ;
691             if (is_array($allowed_schemes) &&
692                 !in_array($scheme, $allowed_schemes)
693             ) {
694                 return false;
695             }
696             if (!empty($matches[4])) {
697                 $parts = explode('.', $matches[4]);
698                 foreach ($parts as $part) {
699                     if ($part > 255) {
700                         return false;
701                     }
702                 }
703             } elseif ($domain_check && function_exists('checkdnsrr')) {
704                 if (!checkdnsrr($authority, 'A')) {
705                     return false;
706                 }
707             }
708             if ($strict) {
709                 $strict = '#[' . preg_quote($strict, '#') . ']#';
710                 if ((!empty($matches[7]) && preg_match($strict, $matches[7]))
711                  || (!empty($matches[8]) && preg_match($strict, $matches[8]))) {
712                     return false;
713                 }
714             }
715             return true;
716         }
717         return false;
718     }
719
720     /**
721      * Validate date and times. Note that this method need the Date_Calc class
722      *
723      * @param string $date    Date to validate
724      * @param array  $options array options where :
725      *                          'format' The format of the date (%d-%m-%Y)
726      *                                   or rfc822_compliant
727      *                          'min'    The date has to be greater
728      *                                   than this array($day, $month, $year)
729      *                                   or PEAR::Date object
730      *                          'max'    The date has to be smaller than
731      *                                   this array($day, $month, $year)
732      *                                   or PEAR::Date object
733      *
734      * @return boolean true if valid date/time, false if not
735      *
736      * @access public
737      */
738     function date($date, $options)
739     {
740         $max    = false;
741         $min    = false;
742         $format = '';
743
744         if (is_array($options)) {
745             extract($options);
746         }
747
748         if (strtolower($format) == 'rfc822_compliant') {
749             $preg = '&^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),) \s+
750                     (?:(\d{2})?) \s+
751                     (?:(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)?) \s+
752                     (?:(\d{2}(\d{2})?)?) \s+
753                     (?:(\d{2}?)):(?:(\d{2}?))(:(?:(\d{2}?)))? \s+
754                     (?:[+-]\d{4}|UT|GMT|EST|EDT|CST|CDT|MST|MDT|PST|PDT|[A-IK-Za-ik-z])$&xi';
755
756             if (!preg_match($preg, $date, $matches)) {
757                 return false;
758             }
759
760             $year    = (int)$matches[4];
761             $months  = array('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
762                              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec');
763             $month   = array_keys($months, $matches[3]);
764             $month   = (int)$month[0]+1;
765             $day     = (int)$matches[2];
766             $weekday = $matches[1];
767             $hour    = (int)$matches[6];
768             $minute  = (int)$matches[7];
769             isset($matches[9]) ? $second = (int)$matches[9] : $second = 0;
770
771             if ((strlen($year) != 4)        ||
772                 ($day    > 31   || $day < 1)||
773                 ($hour   > 23)  ||
774                 ($minute > 59)  ||
775                 ($second > 59)) {
776                     return false;
777             }
778         } else {
779             $date_len = strlen($format);
780             for ($i = 0; $i < $date_len; $i++) {
781                 $c = $format{$i};
782                 if ($c == '%') {
783                     $next = $format{$i + 1};
784                     switch ($next) {
785                     case 'j':
786                     case 'd':
787                         if ($next == 'j') {
788                             $day = (int)Validate::_substr($date, 1, 2);
789                         } else {
790                             $day = (int)Validate::_substr($date, 0, 2);
791                         }
792                         if ($day < 1 || $day > 31) {
793                             return false;
794                         }
795                         break;
796                     case 'm':
797                     case 'n':
798                         if ($next == 'm') {
799                             $month = (int)Validate::_substr($date, 0, 2);
800                         } else {
801                             $month = (int)Validate::_substr($date, 1, 2);
802                         }
803                         if ($month < 1 || $month > 12) {
804                             return false;
805                         }
806                         break;
807                     case 'Y':
808                     case 'y':
809                         if ($next == 'Y') {
810                             $year = Validate::_substr($date, 4);
811                             $year = (int)$year?$year:'';
812                         } else {
813                             $year = (int)(substr(date('Y'), 0, 2) .
814                                               Validate::_substr($date, 2));
815                         }
816                         if (strlen($year) != 4 || $year < 0 || $year > 9999) {
817                             return false;
818                         }
819                         break;
820                     case 'g':
821                     case 'h':
822                         if ($next == 'g') {
823                             $hour = Validate::_substr($date, 1, 2);
824                         } else {
825                             $hour = Validate::_substr($date, 2);
826                         }
827                         if (!preg_match('/^\d+$/', $hour) || $hour < 0 || $hour > 12) {
828                             return false;
829                         }
830                         break;
831                     case 'G':
832                     case 'H':
833                         if ($next == 'G') {
834                             $hour = Validate::_substr($date, 1, 2);
835                         } else {
836                             $hour = Validate::_substr($date, 2);
837                         }
838                         if (!preg_match('/^\d+$/', $hour) || $hour < 0 || $hour > 24) {
839                             return false;
840                         }
841                         break;
842                     case 's':
843                     case 'i':
844                         $t = Validate::_substr($date, 2);
845                         if (!preg_match('/^\d+$/', $t) || $t < 0 || $t > 59) {
846                             return false;
847                         }
848                         break;
849                     default:
850                         trigger_error("Not supported char `$next' after % in offset " . ($i+2), E_USER_WARNING);
851                     }
852                     $i++;
853                 } else {
854                     //literal
855                     if (Validate::_substr($date, 1) != $c) {
856                         return false;
857                     }
858                 }
859             }
860         }
861         // there is remaing data, we don't want it
862         if (strlen($date) && (strtolower($format) != 'rfc822_compliant')) {
863             return false;
864         }
865
866         if (isset($day) && isset($month) && isset($year)) {
867             if (!checkdate($month, $day, $year)) {
868                 return false;
869             }
870
871             if (strtolower($format) == 'rfc822_compliant') {
872                 if ($weekday != date("D", mktime(0, 0, 0, $month, $day, $year))) {
873                     return false;
874                 }
875             }
876
877             if ($min) {
878                 include_once 'Date/Calc.php';
879                 if (is_a($min, 'Date') &&
880                     (Date_Calc::compareDates($day, $month, $year,
881                         $min->getDay(), $min->getMonth(), $min->getYear()) < 0)
882                 ) {
883                     return false;
884                 } elseif (is_array($min) &&
885                         (Date_Calc::compareDates($day, $month, $year,
886                             $min[0], $min[1], $min[2]) < 0)
887                 ) {
888                     return false;
889                 }
890             }
891
892             if ($max) {
893                 include_once 'Date/Calc.php';
894                 if (is_a($max, 'Date') &&
895                     (Date_Calc::compareDates($day, $month, $year,
896                         $max->getDay(), $max->getMonth(), $max->getYear()) > 0)
897                 ) {
898                     return false;
899                 } elseif (is_array($max) &&
900                         (Date_Calc::compareDates($day, $month, $year,
901                             $max[0], $max[1], $max[2]) > 0)
902                 ) {
903                     return false;
904                 }
905             }
906         }
907
908         return true;
909     }
910
911     /**
912      * Substr
913      *
914      * @param string &$date Date
915      * @param string $num   Length
916      * @param string $opt   Unknown   
917      *
918      * @access private
919      * @return string
920      */
921     function _substr(&$date, $num, $opt = false)
922     {
923         if ($opt && strlen($date) >= $opt && preg_match('/^[0-9]{'.$opt.'}/', $date, $m)) {
924             $ret = $m[0];
925         } else {
926             $ret = substr($date, 0, $num);
927         }
928         $date = substr($date, strlen($ret));
929         return $ret;
930     }
931
932     function _modf($val, $div)
933     {
934         if (function_exists('bcmod')) {
935             return bcmod($val, $div);
936         } elseif (function_exists('fmod')) {
937             return fmod($val, $div);
938         }
939         $r = $val / $div;
940         $i = intval($r);
941         return intval($val - $i * $div + .1);
942     }
943
944     /**
945      * Calculates sum of product of number digits with weights
946      *
947      * @param string $number  number string
948      * @param array  $weights reference to array of weights
949      *
950      * @access protected
951      *
952      * @return int returns product of number digits with weights
953      */
954     function _multWeights($number, &$weights)
955     {
956         if (!is_array($weights)) {
957             return -1;
958         }
959         $sum = 0;
960
961         $count = min(count($weights), strlen($number));
962         if ($count == 0) { // empty string or weights array
963             return -1;
964         }
965         for ($i = 0; $i < $count; ++$i) {
966             $sum += intval(substr($number, $i, 1)) * $weights[$i];
967         }
968
969         return $sum;
970     }
971
972     /**
973      * Calculates control digit for a given number
974      *
975      * @param string $number     number string
976      * @param array  $weights    reference to array of weights
977      * @param int    $modulo     (optionsl) number
978      * @param int    $subtract   (optional) number
979      * @param bool   $allow_high (optional) true if function can return number higher than 10
980      *
981      * @access protected
982      *
983      * @return  int -1 calculated control number is returned
984      */
985     function _getControlNumber($number, &$weights, $modulo = 10, $subtract = 0, $allow_high = false)
986     {
987         // calc sum
988         $sum = Validate::_multWeights($number, $weights);
989         if ($sum == -1) {
990             return -1;
991         }
992         $mod = Validate::_modf($sum, $modulo);  // calculate control digit
993
994         if ($subtract > $mod && $mod > 0) {
995             $mod = $subtract - $mod;
996         }
997         if ($allow_high === false) {
998             $mod %= 10;           // change 10 to zero
999         }
1000         return $mod;
1001     }
1002
1003     /**
1004      * Validates a number
1005      *
1006      * @param string $number   number to validate
1007      * @param array  $weights  reference to array of weights
1008      * @param int    $modulo   (optional) number
1009      * @param int    $subtract (optional) number
1010      *
1011      * @access protected
1012      *
1013      * @return  bool true if valid, false if not
1014      */
1015     function _checkControlNumber($number, &$weights, $modulo = 10, $subtract = 0)
1016     {
1017         if (strlen($number) < count($weights)) {
1018             return false;
1019         }
1020         $target_digit  = substr($number, count($weights), 1);
1021         $control_digit = Validate::_getControlNumber($number, $weights, $modulo, $subtract, $modulo > 10);
1022
1023         if ($control_digit == -1) {
1024             return false;
1025         }
1026         if ($target_digit === 'X' && $control_digit == 10) {
1027             return true;
1028         }
1029         if ($control_digit != $target_digit) {
1030             return false;
1031         }
1032         return true;
1033     }
1034
1035     /**
1036      * Bulk data validation for data introduced in the form of an
1037      * assoc array in the form $var_name => $value.
1038      * Can be used on any of Validate subpackages
1039      *
1040      * @param array   $data     Ex: array('name' => 'toto', 'email' => 'toto@thing.info');
1041      * @param array   $val_type Contains the validation type and all parameters used in.
1042      *                          'val_type' is not optional
1043      *                          others validations properties must have the same name as the function
1044      *                          parameters.
1045      *                          Ex: array('toto'=>array('type'=>'string','format'='toto@thing.info','min_length'=>5));
1046      * @param boolean $remove   if set, the elements not listed in data will be removed
1047      *
1048      * @return array   value name => true|false    the value name comes from the data key
1049      *
1050      * @access public
1051      */
1052     function multiple(&$data, &$val_type, $remove = false)
1053     {
1054         $keys  = array_keys($data);
1055         $valid = array();
1056
1057         foreach ($keys as $var_name) {
1058             if (!isset($val_type[$var_name])) {
1059                 if ($remove) {
1060                     unset($data[$var_name]);
1061                 }
1062                 continue;
1063             }
1064             $opt       = $val_type[$var_name];
1065             $methods   = get_class_methods('Validate');
1066             $val2check = $data[$var_name];
1067             // core validation method
1068             if (in_array(strtolower($opt['type']), $methods)) {
1069                 //$opt[$opt['type']] = $data[$var_name];
1070                 $method = $opt['type'];
1071                 unset($opt['type']);
1072
1073                 if (sizeof($opt) == 1 && is_array(reset($opt))) {
1074                     $opt = array_pop($opt);
1075                 }
1076                 $valid[$var_name] = call_user_func(array('Validate', $method), $val2check, $opt);
1077
1078                 /**
1079                  * external validation method in the form:
1080                  * "<class name><underscore><method name>"
1081                  * Ex: us_ssn will include class Validate/US.php and call method ssn()
1082                  */
1083             } elseif (strpos($opt['type'], '_') !== false) {
1084                 $validateType = explode('_', $opt['type']);
1085                 $method       = array_pop($validateType);
1086                 $class        = implode('_', $validateType);
1087                 $classPath    = str_replace('_', DIRECTORY_SEPARATOR, $class);
1088                 $class        = 'Validate_' . $class;
1089                 if (!@include_once "Validate/$classPath.php") {
1090                     trigger_error("$class isn't installed or you may have some permissoin issues", E_USER_ERROR);
1091                 }
1092
1093                 $ce = substr(phpversion(), 0, 1) > 4 ?
1094                     class_exists($class, false) : class_exists($class);
1095                 if (!$ce ||
1096                     !in_array($method, get_class_methods($class))
1097                 ) {
1098                     trigger_error("Invalid validation type $class::$method",
1099                         E_USER_WARNING);
1100                     continue;
1101                 }
1102                 unset($opt['type']);
1103                 if (sizeof($opt) == 1) {
1104                     $opt = array_pop($opt);
1105                 }
1106                 $valid[$var_name] = call_user_func(array($class, $method),
1107                     $data[$var_name], $opt);
1108             } else {
1109                 trigger_error("Invalid validation type {$opt['type']}",
1110                     E_USER_WARNING);
1111             }
1112         }
1113         return $valid;
1114     }
1115 }
1116