libraries/Form_validation.php

   1 <?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
   2 /**
   3  * CodeIgniter
   4  *
   5  * An open source application development framework for PHP 4.3.2 or newer
   6  *
   7  * @package             CodeIgniter
   8  * @author              ExpressionEngine Dev Team
   9  * @copyright   Copyright (c) 2008 - 2009, EllisLab, Inc.
  10  * @license             http://codeigniter.com/user_guide/license.html
  11  * @link                http://codeigniter.com
  12  * @since               Version 1.0
  13  * @filesource
  14  */
  15
  16 // ------------------------------------------------------------------------
  17
  18 /**
  19  * Form Validation Class
  20  *
  21  * @package             CodeIgniter
  22  * @subpackage  Libraries
  23  * @category    Validation
  24  * @author              ExpressionEngine Dev Team
  25  * @link                http://codeigniter.com/user_guide/libraries/form_validation.html
  26  */
  27 class CI_Form_validation {
  28
  29         var $CI;
  30         var $_field_data                        = array();
  31         var $_config_rules                      = array();
  32         var $_error_array                       = array();
  33         var $_error_messages            = array();
  34         var $_error_prefix                      = '<p>';
  35         var $_error_suffix                      = '</p>';
  36         var $error_string                       = '';
  37         var $_safe_form_data            = FALSE;
  38
  39
  40         /**
  41          * Constructor
  42          *
  43          */
  44         function CI_Form_validation($rules = array())
  45         {
  46                 $this->CI =& get_instance();
  47
  48                 // Validation rules can be stored in a config file.
  49                 $this->_config_rules = $rules;
  50
  51                 // Automatically load the form helper
  52                 $this->CI->load->helper('form');
  53
  54                 // Set the character encoding in MB.
  55                 if (function_exists('mb_internal_encoding'))
  56                 {
  57                         mb_internal_encoding($this->CI->config->item('charset'));
  58                 }
  59
  60                 log_message('debug', "Form Validation Class Initialized");
  61         }
  62
  63         // --------------------------------------------------------------------
  64
  65         /**
  66          * Set Rules
  67          *
  68          * This function takes an array of field names and validation
  69          * rules as input, validates the info, and stores it
  70          *
  71          * @access      public
  72          * @param       mixed
  73          * @param       string
  74          * @return      void
  75          */
  76         function set_rules($field, $label = '', $rules = '')
  77         {
  78                 // No reason to set rules if we have no POST data
  79                 if (count($_POST) == 0)
  80                 {
  81                         return;
  82                 }
  83
  84                 // If an array was passed via the first parameter instead of indidual string
  85                 // values we cycle through it and recursively call this function.
  86                 if (is_array($field))
  87                 {
  88                         foreach ($field as $row)
  89                         {
  90                                 // Houston, we have a problem...
  91                                 if ( ! isset($row['field']) OR ! isset($row['rules']))
  92                                 {
  93                                         continue;
  94                                 }
  95
  96                                 // If the field label wasn't passed we use the field name
  97                                 $label = ( ! isset($row['label'])) ? $row['field'] : $row['label'];
  98
  99                                 // Here we go!
 100                                 $this->set_rules($row['field'], $label, $row['rules']);
 101                         }
 102                         return;
 103                 }
 104
 105                 // No fields? Nothing to do...
 106                 if ( ! is_string($field) OR  ! is_string($rules) OR $field == '')
 107                 {
 108                         return;
 109                 }
 110
 111                 // If the field label wasn't passed we use the field name
 112                 $label = ($label == '') ? $field : $label;
 113
 114                 // Is the field name an array?  We test for the existence of a bracket "[" in
 115                 // the field name to determine this.  If it is an array, we break it apart
 116                 // into its components so that we can fetch the corresponding POST data later
 117                 if (strpos($field, '[') !== FALSE AND preg_match_all('/\[(.*?)\]/', $field, $matches))
 118                 {
 119                         // Note: Due to a bug in current() that affects some versions
 120                         // of PHP we can not pass function call directly into it
 121                         $x = explode('[', $field);
 122                         $indexes[] = current($x);
 123
 124                         for ($i = 0; $i < count($matches['0']); $i++)
 125                         {
 126                                 if ($matches['1'][$i] != '')
 127                                 {
 128                                         $indexes[] = $matches['1'][$i];
 129                                 }
 130                         }
 131
 132                         $is_array = TRUE;
 133                 }
 134                 else
 135                 {
 136                         $indexes        = array();
 137                         $is_array       = FALSE;
 138                 }
 139
 140                 // Build our master array
 141                 $this->_field_data[$field] = array(
 142                                                                                         'field'                         => $field,
 143                                                                                         'label'                         => $label,
 144                                                                                         'rules'                         => $rules,
 145                                                                                         'is_array'                      => $is_array,
 146                                                                                         'keys'                          => $indexes,
 147                                                                                         'postdata'                      => NULL,
 148                                                                                         'error'                         => ''
 149                                                                                         );
 150         }
 151
 152         // --------------------------------------------------------------------
 153
 154         /**
 155          * Set Error Message
 156          *
 157          * Lets users set their own error messages on the fly.  Note:  The key
 158          * name has to match the  function name that it corresponds to.
 159          *
 160          * @access      public
 161          * @param       string
 162          * @param       string
 163          * @return      string
 164          */
 165         function set_message($lang, $val = '')
 166         {
 167                 if ( ! is_array($lang))
 168                 {
 169                         $lang = array($lang => $val);
 170                 }
 171
 172                 $this->_error_messages = array_merge($this->_error_messages, $lang);
 173         }
 174
 175         // --------------------------------------------------------------------
 176
 177         /**
 178          * Set The Error Delimiter
 179          *
 180          * Permits a prefix/suffix to be added to each error message
 181          *
 182          * @access      public
 183          * @param       string
 184          * @param       string
 185          * @return      void
 186          */
 187         function set_error_delimiters($prefix = '<p>', $suffix = '</p>')
 188         {
 189                 $this->_error_prefix = $prefix;
 190                 $this->_error_suffix = $suffix;
 191         }
 192
 193         // --------------------------------------------------------------------
 194
 195         /**
 196          * Get Error Message
 197          *
 198          * Gets the error message associated with a particular field
 199          *
 200          * @access      public
 201          * @param       string  the field name
 202          * @return      void
 203          */
 204         function error($field = '', $prefix = '', $suffix = '')
 205         {
 206                 if ( ! isset($this->_field_data[$field]['error']) OR $this->_field_data[$field]['error'] == '')
 207                 {
 208                         return '';
 209                 }
 210
 211                 if ($prefix == '')
 212                 {
 213                         $prefix = $this->_error_prefix;
 214                 }
 215
 216                 if ($suffix == '')
 217                 {
 218                         $suffix = $this->_error_suffix;
 219                 }
 220
 221                 return $prefix.$this->_field_data[$field]['error'].$suffix;
 222         }
 223
 224         // --------------------------------------------------------------------
 225
 226         /**
 227          * Error String
 228          *
 229          * Returns the error messages as a string, wrapped in the error delimiters
 230          *
 231          * @access      public
 232          * @param       string
 233          * @param       string
 234          * @return      str
 235          */
 236         function error_string($prefix = '', $suffix = '')
 237         {
 238                 // No errrors, validation passes!
 239                 if (count($this->_error_array) === 0)
 240                 {
 241                         return '';
 242                 }
 243
 244                 if ($prefix == '')
 245                 {
 246                         $prefix = $this->_error_prefix;
 247                 }
 248
 249                 if ($suffix == '')
 250                 {
 251                         $suffix = $this->_error_suffix;
 252                 }
 253
 254                 // Generate the error string
 255                 $str = '';
 256                 foreach ($this->_error_array as $val)
 257                 {
 258                         if ($val != '')
 259                         {
 260                                 $str .= $prefix.$val.$suffix."\n";
 261                         }
 262                 }
 263
 264                 return $str;
 265         }
 266
 267         // --------------------------------------------------------------------
 268
 269         /**
 270          * Run the Validator
 271          *
 272          * This function does all the work.
 273          *
 274          * @access      public
 275          * @return      bool
 276          */
 277         function run($group = '')
 278         {
 279                 // Do we even have any data to process?  Mm?
 280                 if (count($_POST) == 0)
 281                 {
 282                         return FALSE;
 283                 }
 284
 285                 // Does the _field_data array containing the validation rules exist?
 286                 // If not, we look to see if they were assigned via a config file
 287                 if (count($this->_field_data) == 0)
 288                 {
 289                         // No validation rules?  We're done...
 290                         if (count($this->_config_rules) == 0)
 291                         {
 292                                 return FALSE;
 293                         }
 294
 295                         // Is there a validation rule for the particular URI being accessed?
 296                         $uri = ($group == '') ? trim($this->CI->uri->ruri_string(), '/') : $group;
 297
 298                         if ($uri != '' AND isset($this->_config_rules[$uri]))
 299                         {
 300                                 $this->set_rules($this->_config_rules[$uri]);
 301                         }
 302                         else
 303                         {
 304                                 $this->set_rules($this->_config_rules);
 305                         }
 306
 307                         // We're we able to set the rules correctly?
 308                         if (count($this->_field_data) == 0)
 309                         {
 310                                 log_message('debug', "Unable to find validation rules");
 311                                 return FALSE;
 312                         }
 313                 }
 314
 315                 // Load the language file containing error messages
 316                 $this->CI->lang->load('form_validation');
 317
 318                 // Cycle through the rules for each field, match the
 319                 // corresponding $_POST item and test for errors
 320                 foreach ($this->_field_data as $field => $row)
 321                 {
 322                         // Fetch the data from the corresponding $_POST array and cache it in the _field_data array.
 323                         // Depending on whether the field name is an array or a string will determine where we get it from.
 324
 325                         if ($row['is_array'] == TRUE)
 326                         {
 327                                 $this->_field_data[$field]['postdata'] = $this->_reduce_array($_POST, $row['keys']);
 328                         }
 329                         else
 330                         {
 331                                 if (isset($_POST[$field]) AND $_POST[$field] != "")
 332                                 {
 333                                         $this->_field_data[$field]['postdata'] = $_POST[$field];
 334                                 }
 335                         }
 336
 337                         $this->_execute($row, explode('|', $row['rules']), $this->_field_data[$field]['postdata']);
 338                 }
 339
 340                 // Did we end up with any errors?
 341                 $total_errors = count($this->_error_array);
 342
 343                 if ($total_errors > 0)
 344                 {
 345                         $this->_safe_form_data = TRUE;
 346                 }
 347
 348                 // Now we need to re-set the POST data with the new, processed data
 349                 $this->_reset_post_array();
 350
 351                 // No errors, validation passes!
 352                 if ($total_errors == 0)
 353                 {
 354                         return TRUE;
 355                 }
 356
 357                 // Validation fails
 358                 return FALSE;
 359         }
 360
 361         // --------------------------------------------------------------------
 362
 363         /**
 364          * Traverse a multidimensional $_POST array index until the data is found
 365          *
 366          * @access      private
 367          * @param       array
 368          * @param       array
 369          * @param       integer
 370          * @return      mixed
 371          */
 372         function _reduce_array($array, $keys, $i = 0)
 373         {
 374                 if (is_array($array))
 375                 {
 376                         if (isset($keys[$i]))
 377                         {
 378                                 if (isset($array[$keys[$i]]))
 379                                 {
 380                                         $array = $this->_reduce_array($array[$keys[$i]], $keys, ($i+1));
 381                                 }
 382                                 else
 383                                 {
 384                                         return NULL;
 385                                 }
 386                         }
 387                         else
 388                         {
 389                                 return $array;
 390                         }
 391                 }
 392
 393                 return $array;
 394         }
 395
 396         // --------------------------------------------------------------------
 397
 398         /**
 399          * Re-populate the _POST array with our finalized and processed data
 400          *
 401          * @access      private
 402          * @return      null
 403          */
 404         function _reset_post_array()
 405         {
 406                 foreach ($this->_field_data as $field => $row)
 407                 {
 408                         if ( ! is_null($row['postdata']))
 409                         {
 410                                 if ($row['is_array'] == FALSE)
 411                                 {
 412                                         if (isset($_POST[$row['field']]))
 413                                         {
 414                                                 $_POST[$row['field']] = $this->prep_for_form($row['postdata']);
 415                                         }
 416                                 }
 417                                 else
 418                                 {
 419                                         // start with a reference
 420                                         $post_ref =& $_POST;
 421
 422                                         // before we assign values, make a reference to the right POST key
 423                                         if (count($row['keys']) == 1)
 424                                         {
 425                                                 $post_ref =& $post_ref[current($row['keys'])];
 426                                         }
 427                                         else
 428                                         {
 429                                                 foreach ($row['keys'] as $val)
 430                                                 {
 431                                                         $post_ref =& $post_ref[$val];
 432                                                 }
 433                                         }
 434
 435                                         if (is_array($row['postdata']))
 436                                         {
 437                                                 $array = array();
 438                                                 foreach ($row['postdata'] as $k => $v)
 439                                                 {
 440                                                         $array[$k] = $this->prep_for_form($v);
 441                                                 }
 442
 443                                                 $post_ref = $array;
 444                                         }
 445                                         else
 446                                         {
 447                                                 $post_ref = $this->prep_for_form($row['postdata']);
 448                                         }
 449                                 }
 450                         }
 451                 }
 452         }
 453
 454         // --------------------------------------------------------------------
 455
 456         /**
 457          * Executes the Validation routines
 458          *
 459          * @access      private
 460          * @param       array
 461          * @param       array
 462          * @param       mixed
 463          * @param       integer
 464          * @return      mixed
 465          */
 466         function _execute($row, $rules, $postdata = NULL, $cycles = 0)
 467         {
 468                 // If the $_POST data is an array we will run a recursive call
 469                 if (is_array($postdata))
 470                 {
 471                         foreach ($postdata as $key => $val)
 472                         {
 473                                 $this->_execute($row, $rules, $val, $cycles);
 474                                 $cycles++;
 475                         }
 476
 477                         return;
 478                 }
 479
 480                 // --------------------------------------------------------------------
 481
 482                 // If the field is blank, but NOT required, no further tests are necessary
 483                 $callback = FALSE;
 484                 if ( ! in_array('required', $rules) AND is_null($postdata))
 485                 {
 486                         // Before we bail out, does the rule contain a callback?
 487                         if (preg_match("/(callback_\w+)/", implode(' ', $rules), $match))
 488                         {
 489                                 $callback = TRUE;
 490                                 $rules = (array('1' => $match[1]));
 491                         }
 492                         else
 493                         {
 494                                 return;
 495                         }
 496                 }
 497
 498                 // --------------------------------------------------------------------
 499
 500                 // Isset Test. Typically this rule will only apply to checkboxes.
 501                 if (is_null($postdata) AND $callback == FALSE)
 502                 {
 503                         if (in_array('isset', $rules, TRUE) OR in_array('required', $rules))
 504                         {
 505                                 // Set the message type
 506                                 $type = (in_array('required', $rules)) ? 'required' : 'isset';
 507
 508                                 if ( ! isset($this->_error_messages[$type]))
 509                                 {
 510                                         if (FALSE === ($line = $this->CI->lang->line($type)))
 511                                         {
 512                                                 $line = 'The field was not set';
 513                                         }
 514                                 }
 515                                 else
 516                                 {
 517                                         $line = $this->_error_messages[$type];
 518                                 }
 519
 520                                 // Build the error message
 521                                 $message = sprintf($line, $this->_translate_fieldname($row['label']));
 522
 523                                 // Save the error message
 524                                 $this->_field_data[$row['field']]['error'] = $message;
 525
 526                                 if ( ! isset($this->_error_array[$row['field']]))
 527                                 {
 528                                         $this->_error_array[$row['field']] = $message;
 529                                 }
 530                         }
 531
 532                         return;
 533                 }
 534
 535                 // --------------------------------------------------------------------
 536
 537                 // Cycle through each rule and run it
 538                 foreach ($rules As $rule)
 539                 {
 540                         $_in_array = FALSE;
 541
 542                         // We set the $postdata variable with the current data in our master array so that
 543                         // each cycle of the loop is dealing with the processed data from the last cycle
 544                         if ($row['is_array'] == TRUE AND is_array($this->_field_data[$row['field']]['postdata']))
 545                         {
 546                                 // We shouldn't need this safety, but just in case there isn't an array index
 547                                 // associated with this cycle we'll bail out
 548                                 if ( ! isset($this->_field_data[$row['field']]['postdata'][$cycles]))
 549                                 {
 550                                         continue;
 551                                 }
 552
 553                                 $postdata = $this->_field_data[$row['field']]['postdata'][$cycles];
 554                                 $_in_array = TRUE;
 555                         }
 556                         else
 557                         {
 558                                 $postdata = $this->_field_data[$row['field']]['postdata'];
 559                         }
 560
 561                         // --------------------------------------------------------------------
 562
 563                         // Is the rule a callback?
 564                         $callback = FALSE;
 565                         if (substr($rule, 0, 9) == 'callback_')
 566                         {
 567                                 $rule = substr($rule, 9);
 568                                 $callback = TRUE;
 569                         }
 570
 571                         // Strip the parameter (if exists) from the rule
 572                         // Rules can contain a parameter: max_length[5]
 573                         $param = FALSE;
 574                         if (preg_match("/(.*?)\[(.*?)\]/", $rule, $match))
 575                         {
 576                                 $rule   = $match[1];
 577                                 $param  = $match[2];
 578                         }
 579
 580                         // Call the function that corresponds to the rule
 581                         if ($callback === TRUE)
 582                         {
 583                                 if ( ! method_exists($this->CI, $rule))
 584                                 {
 585                                         continue;
 586                                 }
 587
 588                                 // Run the function and grab the result
 589                                 $result = $this->CI->$rule($postdata, $param);
 590
 591                                 // Re-assign the result to the master data array
 592                                 if ($_in_array == TRUE)
 593                                 {
 594                                         $this->_field_data[$row['field']]['postdata'][$cycles] = (is_bool($result)) ? $postdata : $result;
 595                                 }
 596                                 else
 597                                 {
 598                                         $this->_field_data[$row['field']]['postdata'] = (is_bool($result)) ? $postdata : $result;
 599                                 }
 600
 601                                 // If the field isn't required and we just processed a callback we'll move on...
 602                                 if ( ! in_array('required', $rules, TRUE) AND $result !== FALSE)
 603                                 {
 604                                         continue;
 605                                 }
 606                         }
 607                         else
 608                         {
 609                                 if ( ! method_exists($this, $rule))
 610                                 {
 611                                         // If our own wrapper function doesn't exist we see if a native PHP function does.
 612                                         // Users can use any native PHP function call that has one param.
 613                                         if (function_exists($rule))
 614                                         {
 615                                                 $result = $rule($postdata);
 616
 617                                                 if ($_in_array == TRUE)
 618                                                 {
 619                                                         $this->_field_data[$row['field']]['postdata'][$cycles] = (is_bool($result)) ? $postdata : $result;
 620                                                 }
 621                                                 else
 622                                                 {
 623                                                         $this->_field_data[$row['field']]['postdata'] = (is_bool($result)) ? $postdata : $result;
 624                                                 }
 625                                         }
 626
 627                                         continue;
 628                                 }
 629
 630                                 $result = $this->$rule($postdata, $param);
 631
 632                                 if ($_in_array == TRUE)
 633                                 {
 634                                         $this->_field_data[$row['field']]['postdata'][$cycles] = (is_bool($result)) ? $postdata : $result;
 635                                 }
 636                                 else
 637                                 {
 638                                         $this->_field_data[$row['field']]['postdata'] = (is_bool($result)) ? $postdata : $result;
 639                                 }
 640                         }
 641
 642                         // Did the rule test negatively?  If so, grab the error.
 643                         if ($result === FALSE)
 644                         {
 645                                 if ( ! isset($this->_error_messages[$rule]))
 646                                 {
 647                                         if (FALSE === ($line = $this->CI->lang->line($rule)))
 648                                         {
 649                                                 $line = 'Unable to access an error message corresponding to your field name.';
 650                                         }
 651                                 }
 652                                 else
 653                                 {
 654                                         $line = $this->_error_messages[$rule];
 655                                 }
 656
 657                                 // Is the parameter we are inserting into the error message the name
 658                                 // of another field?  If so we need to grab its "field label"
 659                                 if (isset($this->_field_data[$param]) AND isset($this->_field_data[$param]['label']))
 660                                 {
 661                                         $param = $this->_field_data[$param]['label'];
 662                                 }
 663
 664                                 // Build the error message
 665                                 $message = sprintf($line, $this->_translate_fieldname($row['label']), $param);
 666
 667                                 // Save the error message
 668                                 $this->_field_data[$row['field']]['error'] = $message;
 669
 670                                 if ( ! isset($this->_error_array[$row['field']]))
 671                                 {
 672                                         $this->_error_array[$row['field']] = $message;
 673                                 }
 674
 675                                 return;
 676                         }
 677                 }
 678         }
 679
 680         // --------------------------------------------------------------------
 681
 682         /**
 683          * Translate a field name
 684          *
 685          * @access      private
 686          * @param       string  the field name
 687          * @return      string
 688          */
 689         function _translate_fieldname($fieldname)
 690         {
 691                 // Do we need to translate the field name?
 692                 // We look for the prefix lang: to determine this
 693                 if (substr($fieldname, 0, 5) == 'lang:')
 694                 {
 695                         // Grab the variable
 696                         $line = substr($fieldname, 5);
 697
 698                         // Were we able to translate the field name?  If not we use $line
 699                         if (FALSE === ($fieldname = $this->CI->lang->line($line)))
 700                         {
 701                                 return $line;
 702                         }
 703                 }
 704
 705                 return $fieldname;
 706         }
 707
 708         // --------------------------------------------------------------------
 709
 710         /**
 711          * Get the value from a form
 712          *
 713          * Permits you to repopulate a form field with the value it was submitted
 714          * with, or, if that value doesn't exist, with the default
 715          *
 716          * @access      public
 717          * @param       string  the field name
 718          * @param       string
 719          * @return      void
 720          */
 721         function set_value($field = '', $default = '')
 722         {
 723                 if ( ! isset($this->_field_data[$field]))
 724                 {
 725                         return $default;
 726                 }
 727
 728                 return $this->_field_data[$field]['postdata'];
 729         }
 730
 731         // --------------------------------------------------------------------
 732
 733         /**
 734          * Set Select
 735          *
 736          * Enables pull-down lists to be set to the value the user
 737          * selected in the event of an error
 738          *
 739          * @access      public
 740          * @param       string
 741          * @param       string
 742          * @return      string
 743          */
 744         function set_select($field = '', $value = '', $default = FALSE)
 745         {
 746                 if ( ! isset($this->_field_data[$field]) OR ! isset($this->_field_data[$field]['postdata']))
 747                 {
 748                         if ($default === TRUE AND count($this->_field_data) === 0)
 749                         {
 750                                 return ' selected="selected"';
 751                         }
 752                         return '';
 753                 }
 754
 755                 $field = $this->_field_data[$field]['postdata'];
 756
 757                 if (is_array($field))
 758                 {
 759                         if ( ! in_array($value, $field))
 760                         {
 761                                 return '';
 762                         }
 763                 }
 764                 else
 765                 {
 766                         if (($field == '' OR $value == '') OR ($field != $value))
 767                         {
 768                                 return '';
 769                         }
 770                 }
 771
 772                 return ' selected="selected"';
 773         }
 774
 775         // --------------------------------------------------------------------
 776
 777         /**
 778          * Set Radio
 779          *
 780          * Enables radio buttons to be set to the value the user
 781          * selected in the event of an error
 782          *
 783          * @access      public
 784          * @param       string
 785          * @param       string
 786          * @return      string
 787          */
 788         function set_radio($field = '', $value = '', $default = FALSE)
 789         {
 790                 if ( ! isset($this->_field_data[$field]) OR ! isset($this->_field_data[$field]['postdata']))
 791                 {
 792                         if ($default === TRUE AND count($this->_field_data) === 0)
 793                         {
 794                                 return ' checked="checked"';
 795                         }
 796                         return '';
 797                 }
 798
 799                 $field = $this->_field_data[$field]['postdata'];
 800
 801                 if (is_array($field))
 802                 {
 803                         if ( ! in_array($value, $field))
 804                         {
 805                                 return '';
 806                         }
 807                 }
 808                 else
 809                 {
 810                         if (($field == '' OR $value == '') OR ($field != $value))
 811                         {
 812                                 return '';
 813                         }
 814                 }
 815
 816                 return ' checked="checked"';
 817         }
 818
 819         // --------------------------------------------------------------------
 820
 821         /**
 822          * Set Checkbox
 823          *
 824          * Enables checkboxes to be set to the value the user
 825          * selected in the event of an error
 826          *
 827          * @access      public
 828          * @param       string
 829          * @param       string
 830          * @return      string
 831          */
 832         function set_checkbox($field = '', $value = '', $default = FALSE)
 833         {
 834                 if ( ! isset($this->_field_data[$field]) OR ! isset($this->_field_data[$field]['postdata']))
 835                 {
 836                         if ($default === TRUE AND count($this->_field_data) === 0)
 837                         {
 838                                 return ' checked="checked"';
 839                         }
 840                         return '';
 841                 }
 842
 843                 $field = $this->_field_data[$field]['postdata'];
 844
 845                 if (is_array($field))
 846                 {
 847                         if ( ! in_array($value, $field))
 848                         {
 849                                 return '';
 850                         }
 851                 }
 852                 else
 853                 {
 854                         if (($field == '' OR $value == '') OR ($field != $value))
 855                         {
 856                                 return '';
 857                         }
 858                 }
 859
 860                 return ' checked="checked"';
 861         }
 862
 863         // --------------------------------------------------------------------
 864
 865         /**
 866          * Required
 867          *
 868          * @access      public
 869          * @param       string
 870          * @return      bool
 871          */
 872         function required($str)
 873         {
 874                 if ( ! is_array($str))
 875                 {
 876                         return (trim($str) == '') ? FALSE : TRUE;
 877                 }
 878                 else
 879                 {
 880                         return ( ! empty($str));
 881                 }
 882         }
 883
 884         // --------------------------------------------------------------------
 885
 886         /**
 887          * Match one field to another
 888          *
 889          * @access      public
 890          * @param       string
 891          * @param       field
 892          * @return      bool
 893          */
 894         function matches($str, $field)
 895         {
 896                 if ( ! isset($_POST[$field]))
 897                 {
 898                         return FALSE;
 899                 }
 900
 901                 $field = $_POST[$field];
 902
 903                 return ($str !== $field) ? FALSE : TRUE;
 904         }
 905
 906         // --------------------------------------------------------------------
 907
 908         /**
 909          * Minimum Length
 910          *
 911          * @access      public
 912          * @param       string
 913          * @param       value
 914          * @return      bool
 915          */
 916         function min_length($str, $val)
 917         {
 918                 if (preg_match("/[^0-9]/", $val))
 919                 {
 920                         return FALSE;
 921                 }
 922
 923                 if (function_exists('mb_strlen'))
 924                 {
 925                         return (mb_strlen($str) < $val) ? FALSE : TRUE;
 926                 }
 927
 928                 return (strlen($str) < $val) ? FALSE : TRUE;
 929         }
 930
 931         // --------------------------------------------------------------------
 932
 933         /**
 934          * Max Length
 935          *
 936          * @access      public
 937          * @param       string
 938          * @param       value
 939          * @return      bool
 940          */
 941         function max_length($str, $val)
 942         {
 943                 if (preg_match("/[^0-9]/", $val))
 944                 {
 945                         return FALSE;
 946                 }
 947
 948                 if (function_exists('mb_strlen'))
 949                 {
 950                         return (mb_strlen($str) > $val) ? FALSE : TRUE;
 951                 }
 952
 953                 return (strlen($str) > $val) ? FALSE : TRUE;
 954         }
 955
 956         // --------------------------------------------------------------------
 957
 958         /**
 959          * Exact Length
 960          *
 961          * @access      public
 962          * @param       string
 963          * @param       value
 964          * @return      bool
 965          */
 966         function exact_length($str, $val)
 967         {
 968                 if (preg_match("/[^0-9]/", $val))
 969                 {
 970                         return FALSE;
 971                 }
 972
 973                 if (function_exists('mb_strlen'))
 974                 {
 975                         return (mb_strlen($str) != $val) ? FALSE : TRUE;
 976                 }
 977
 978                 return (strlen($str) != $val) ? FALSE : TRUE;
 979         }
 980
 981         // --------------------------------------------------------------------
 982
 983         /**
 984          * Valid Email
 985          *
 986          * @access      public
 987          * @param       string
 988          * @return      bool
 989          */
 990         function valid_email($str)
 991         {
 992                 return ( ! preg_match("/^([a-z0-9\+_\-]+)(\.[a-z0-9\+_\-]+)*@([a-z0-9\-]+\.)+[a-z]{2,6}$/ix", $str)) ? FALSE : TRUE;
 993         }
 994
 995         // --------------------------------------------------------------------
 996
 997         /**
 998          * Valid Emails
 999          *
1000          * @access      public
1001          * @param       string
1002          * @return      bool
1003          */
1004         function valid_emails($str)
1005         {
1006                 if (strpos($str, ',') === FALSE)
1007                 {
1008                         return $this->valid_email(trim($str));
1009                 }
1010
1011                 foreach(explode(',', $str) as $email)
1012                 {
1013                         if (trim($email) != '' && $this->valid_email(trim($email)) === FALSE)
1014                         {
1015                                 return FALSE;
1016                         }
1017                 }
1018
1019                 return TRUE;
1020         }
1021
1022         // --------------------------------------------------------------------
1023
1024         /**
1025          * Validate IP Address
1026          *
1027          * @access      public
1028          * @param       string
1029          * @return      string
1030          */
1031         function valid_ip($ip)
1032         {
1033                 return $this->CI->input->valid_ip($ip);
1034         }
1035
1036         // --------------------------------------------------------------------
1037
1038         /**
1039          * Alpha
1040          *
1041          * @access      public
1042          * @param       string
1043          * @return      bool
1044          */
1045         function alpha($str)
1046         {
1047                 return ( ! preg_match("/^([a-z])+$/i", $str)) ? FALSE : TRUE;
1048         }
1049
1050         // --------------------------------------------------------------------
1051
1052         /**
1053          * Alpha-numeric
1054          *
1055          * @access      public
1056          * @param       string
1057          * @return      bool
1058          */
1059         function alpha_numeric($str)
1060         {
1061                 return ( ! preg_match("/^([a-z0-9])+$/i", $str)) ? FALSE : TRUE;
1062         }
1063
1064         // --------------------------------------------------------------------
1065
1066         /**
1067          * Alpha-numeric with underscores and dashes
1068          *
1069          * @access      public
1070          * @param       string
1071          * @return      bool
1072          */
1073         function alpha_dash($str)
1074         {
1075                 return ( ! preg_match("/^([-a-z0-9_-])+$/i", $str)) ? FALSE : TRUE;
1076         }
1077
1078         // --------------------------------------------------------------------
1079
1080         /**
1081          * Numeric
1082          *
1083          * @access      public
1084          * @param       string
1085          * @return      bool
1086          */
1087         function numeric($str)
1088         {
1089                 return (bool)preg_match( '/^[\-+]?[0-9]*\.?[0-9]+$/', $str);
1090
1091         }
1092
1093         // --------------------------------------------------------------------
1094
1095     /**
1096      * Is Numeric
1097      *
1098      * @access    public
1099      * @param    string
1100      * @return    bool
1101      */
1102     function is_numeric($str)
1103     {
1104         return ( ! is_numeric($str)) ? FALSE : TRUE;
1105     }
1106
1107         // --------------------------------------------------------------------
1108
1109         /**
1110          * Integer
1111          *
1112          * @access      public
1113          * @param       string
1114          * @return      bool
1115          */
1116         function integer($str)
1117         {
1118                 return (bool)preg_match( '/^[\-+]?[0-9]+$/', $str);
1119         }
1120
1121         // --------------------------------------------------------------------
1122
1123     /**
1124      * Is a Natural number  (0,1,2,3, etc.)
1125      *
1126      * @access  public
1127      * @param   string
1128      * @return  bool
1129      */
1130     function is_natural($str)
1131     {
1132                 return (bool)preg_match( '/^[0-9]+$/', $str);
1133     }
1134
1135         // --------------------------------------------------------------------
1136
1137     /**
1138      * Is a Natural number, but not a zero  (1,2,3, etc.)
1139      *
1140      * @access  public
1141      * @param   string
1142      * @return  bool
1143      */
1144         function is_natural_no_zero($str)
1145     {
1146         if ( ! preg_match( '/^[0-9]+$/', $str))
1147         {
1148                 return FALSE;
1149         }
1150
1151         if ($str == 0)
1152         {
1153                 return FALSE;
1154         }
1155
1156                 return TRUE;
1157     }
1158
1159         // --------------------------------------------------------------------
1160
1161         /**
1162          * Valid Base64
1163          *
1164          * Tests a string for characters outside of the Base64 alphabet
1165          * as defined by RFC 2045 http://www.faqs.org/rfcs/rfc2045
1166          *
1167          * @access      public
1168          * @param       string
1169          * @return      bool
1170          */
1171         function valid_base64($str)
1172         {
1173                 return (bool) ! preg_match('/[^a-zA-Z0-9\/\+=]/', $str);
1174         }
1175
1176         // --------------------------------------------------------------------
1177
1178         /**
1179          * Prep data for form
1180          *
1181          * This function allows HTML to be safely shown in a form.
1182          * Special characters are converted.
1183          *
1184          * @access      public
1185          * @param       string
1186          * @return      string
1187          */
1188         function prep_for_form($data = '')
1189         {
1190                 if (is_array($data))
1191                 {
1192                         foreach ($data as $key => $val)
1193                         {
1194                                 $data[$key] = $this->prep_for_form($val);
1195                         }
1196
1197                         return $data;
1198                 }
1199
1200                 if ($this->_safe_form_data == FALSE OR $data === '')
1201                 {
1202                         return $data;
1203                 }
1204
1205                 return str_replace(array("'", '"', '<', '>'), array("&#39;", "&quot;", '&lt;', '&gt;'), stripslashes($data));
1206         }
1207
1208         // --------------------------------------------------------------------
1209
1210         /**
1211          * Prep URL
1212          *
1213          * @access      public
1214          * @param       string
1215          * @return      string
1216          */
1217         function prep_url($str = '')
1218         {
1219                 if ($str == 'http://' OR $str == '')
1220                 {
1221                         return '';
1222                 }
1223
1224                 if (substr($str, 0, 7) != 'http://' && substr($str, 0, 8) != 'https://')
1225                 {
1226                         $str = 'http://'.$str;
1227                 }
1228
1229                 return $str;
1230         }
1231
1232         // --------------------------------------------------------------------
1233
1234         /**
1235          * Strip Image Tags
1236          *
1237          * @access      public
1238          * @param       string
1239          * @return      string
1240          */
1241         function strip_image_tags($str)
1242         {
1243                 return $this->CI->input->strip_image_tags($str);
1244         }
1245
1246         // --------------------------------------------------------------------
1247
1248         /**
1249          * XSS Clean
1250          *
1251          * @access      public
1252          * @param       string
1253          * @return      string
1254          */
1255         function xss_clean($str)
1256         {
1257                 return $this->CI->input->xss_clean($str);
1258         }
1259
1260         // --------------------------------------------------------------------
1261
1262         /**
1263          * Convert PHP tags to entities
1264          *
1265          * @access      public
1266          * @param       string
1267          * @return      string
1268          */
1269         function encode_php_tags($str)
1270         {
1271                 return str_replace(array('<?php', '<?PHP', '<?', '?>'),  array('&lt;?php', '&lt;?PHP', '&lt;?', '?&gt;'), $str);
1272         }
1273
1274 }
1275 // END Form Validation Class
1276
1277 /* End of file Form_validation.php */
1278 /* Location: ./system/libraries/Form_validation.php */