interface/modules/zend_modules/library/Zend/Validator/EmailAddress.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Validator;
  11
  12 class EmailAddress extends AbstractValidator
  13 {
  14     const INVALID            = 'emailAddressInvalid';
  15     const INVALID_FORMAT     = 'emailAddressInvalidFormat';
  16     const INVALID_HOSTNAME   = 'emailAddressInvalidHostname';
  17     const INVALID_MX_RECORD  = 'emailAddressInvalidMxRecord';
  18     const INVALID_SEGMENT    = 'emailAddressInvalidSegment';
  19     const DOT_ATOM           = 'emailAddressDotAtom';
  20     const QUOTED_STRING      = 'emailAddressQuotedString';
  21     const INVALID_LOCAL_PART = 'emailAddressInvalidLocalPart';
  22     const LENGTH_EXCEEDED    = 'emailAddressLengthExceeded';
  23
  24     /**
  25      * @var array
  26      */
  27     protected $messageTemplates = array(
  28         self::INVALID            => "Invalid type given. String expected",
  29         self::INVALID_FORMAT     => "The input is not a valid email address. Use the basic format local-part@hostname",
  30         self::INVALID_HOSTNAME   => "'%hostname%' is not a valid hostname for the email address",
  31         self::INVALID_MX_RECORD  => "'%hostname%' does not appear to have any valid MX or A records for the email address",
  32         self::INVALID_SEGMENT    => "'%hostname%' is not in a routable network segment. The email address should not be resolved from public network",
  33         self::DOT_ATOM           => "'%localPart%' can not be matched against dot-atom format",
  34         self::QUOTED_STRING      => "'%localPart%' can not be matched against quoted-string format",
  35         self::INVALID_LOCAL_PART => "'%localPart%' is not a valid local part for the email address",
  36         self::LENGTH_EXCEEDED    => "The input exceeds the allowed length",
  37     );
  38
  39     /**
  40      * @var array
  41      */
  42     protected $messageVariables = array(
  43         'hostname'  => 'hostname',
  44         'localPart' => 'localPart'
  45     );
  46
  47     /**
  48      * @var string
  49      */
  50     protected $hostname;
  51
  52     /**
  53      * @var string
  54      */
  55     protected $localPart;
  56
  57     /**
  58      * Returns the found mx record informations
  59      *
  60      * @var array
  61      */
  62     protected $mxRecord;
  63
  64     /**
  65      * Internal options array
  66      */
  67     protected $options = array(
  68         'useMxCheck'        => false,
  69         'useDeepMxCheck'    => false,
  70         'useDomainCheck'    => true,
  71         'allow'             => Hostname::ALLOW_DNS,
  72         'hostnameValidator' => null,
  73     );
  74
  75     /**
  76      * Instantiates hostname validator for local use
  77      *
  78      * The following additional option keys are supported:
  79      * 'hostnameValidator' => A hostname validator, see Zend\Validator\Hostname
  80      * 'allow'             => Options for the hostname validator, see Zend\Validator\Hostname::ALLOW_*
  81      * 'useMxCheck'        => If MX check should be enabled, boolean
  82      * 'useDeepMxCheck'    => If a deep MX check should be done, boolean
  83      *
  84      * @param array|\Traversable $options OPTIONAL
  85      */
  86     public function __construct($options = array())
  87     {
  88         if (!is_array($options)) {
  89             $options = func_get_args();
  90             $temp['allow'] = array_shift($options);
  91             if (!empty($options)) {
  92                 $temp['useMxCheck'] = array_shift($options);
  93             }
  94
  95             if (!empty($options)) {
  96                 $temp['hostnameValidator'] = array_shift($options);
  97             }
  98
  99             $options = $temp;
 100         }
 101
 102         parent::__construct($options);
 103     }
 104
 105     /**
 106      * Sets the validation failure message template for a particular key
 107      * Adds the ability to set messages to the attached hostname validator
 108      *
 109      * @param  string $messageString
 110      * @param  string $messageKey     OPTIONAL
 111      * @return AbstractValidator Provides a fluent interface
 112      */
 113     public function setMessage($messageString, $messageKey = null)
 114     {
 115         if ($messageKey === null) {
 116             $this->getHostnameValidator()->setMessage($messageString);
 117             parent::setMessage($messageString);
 118             return $this;
 119         }
 120
 121         if (!isset($this->messageTemplates[$messageKey])) {
 122             $this->getHostnameValidator()->setMessage($messageString, $messageKey);
 123         } else {
 124             parent::setMessage($messageString, $messageKey);
 125         }
 126
 127         return $this;
 128     }
 129
 130     /**
 131      * Returns the set hostname validator
 132      *
 133      * If was not previously set then lazy load a new one
 134      *
 135      * @return Hostname
 136      */
 137     public function getHostnameValidator()
 138     {
 139         if (!isset($this->options['hostnameValidator'])) {
 140             $this->options['hostnameValidator'] = new Hostname($this->getAllow());
 141         }
 142
 143         return $this->options['hostnameValidator'];
 144     }
 145
 146     /**
 147      * @param Hostname $hostnameValidator OPTIONAL
 148      * @return EmailAddress Provides a fluent interface
 149      */
 150     public function setHostnameValidator(Hostname $hostnameValidator = null)
 151     {
 152         $this->options['hostnameValidator'] = $hostnameValidator;
 153
 154         return $this;
 155     }
 156
 157     /**
 158      * Returns the allow option of the attached hostname validator
 159      *
 160      * @return int
 161      */
 162     public function getAllow()
 163     {
 164         return $this->options['allow'];
 165     }
 166
 167     /**
 168      * Sets the allow option of the hostname validator to use
 169      *
 170      * @param int $allow
 171      * @return EmailAddress Provides a fluent interface
 172      */
 173     public function setAllow($allow)
 174     {
 175         $this->options['allow'] = $allow;
 176         if (isset($this->options['hostnameValidator'])) {
 177             $this->options['hostnameValidator']->setAllow($allow);
 178         }
 179
 180         return $this;
 181     }
 182
 183     /**
 184      * Whether MX checking via getmxrr is supported or not
 185      *
 186      * @return bool
 187      */
 188     public function isMxSupported()
 189     {
 190         return function_exists('getmxrr');
 191     }
 192
 193     /**
 194      * Returns the set validateMx option
 195      *
 196      * @return bool
 197      */
 198     public function getMxCheck()
 199     {
 200         return $this->options['useMxCheck'];
 201     }
 202
 203     /**
 204      * Set whether we check for a valid MX record via DNS
 205      *
 206      * This only applies when DNS hostnames are validated
 207      *
 208      * @param  bool $mx Set allowed to true to validate for MX records, and false to not validate them
 209      * @return EmailAddress Fluid Interface
 210      */
 211     public function useMxCheck($mx)
 212     {
 213         $this->options['useMxCheck'] = (bool) $mx;
 214         return $this;
 215     }
 216
 217     /**
 218      * Returns the set deepMxCheck option
 219      *
 220      * @return bool
 221      */
 222     public function getDeepMxCheck()
 223     {
 224         return $this->options['useDeepMxCheck'];
 225     }
 226
 227     /**
 228      * Use deep validation for MX records
 229      *
 230      * @param  bool $deep Set deep to true to perform a deep validation process for MX records
 231      * @return EmailAddress Fluid Interface
 232      */
 233     public function useDeepMxCheck($deep)
 234     {
 235         $this->options['useDeepMxCheck'] = (bool) $deep;
 236         return $this;
 237     }
 238
 239     /**
 240      * Returns the set domainCheck option
 241      *
 242      * @return bool
 243      */
 244     public function getDomainCheck()
 245     {
 246         return $this->options['useDomainCheck'];
 247     }
 248
 249     /**
 250      * Sets if the domain should also be checked
 251      * or only the local part of the email address
 252      *
 253      * @param  bool $domain
 254      * @return EmailAddress Fluid Interface
 255      */
 256     public function useDomainCheck($domain = true)
 257     {
 258         $this->options['useDomainCheck'] = (bool) $domain;
 259         return $this;
 260     }
 261
 262     /**
 263      * Returns if the given host is reserved
 264      *
 265      * The following addresses are seen as reserved
 266      * '0.0.0.0/8', '10.0.0.0/8', '127.0.0.0/8'
 267      * '100.64.0.0/10'
 268      * '172.16.0.0/12'
 269      * '198.18.0.0/15'
 270      * '169.254.0.0/16', '192.168.0.0/16'
 271      * '192.0.2.0/24', '192.88.99.0/24', '198.51.100.0/24', '203.0.113.0/24'
 272      * '224.0.0.0/4', '240.0.0.0/4'
 273      * @see http://en.wikipedia.org/wiki/Reserved_IP_addresses
 274      *
 275      * As of RFC5753 (JAN 2010), the following blocks are no longer reserved:
 276      *   - 128.0.0.0/16
 277      *   - 191.255.0.0/16
 278      *   - 223.255.255.0/24
 279      * @see http://tools.ietf.org/html/rfc5735#page-6
 280      *
 281      * As of RFC6598 (APR 2012), the following blocks are now reserved:
 282      *   - 100.64.0.0/10
 283      * @see http://tools.ietf.org/html/rfc6598#section-7
 284      *
 285      * @param string $host
 286      * @return bool Returns false when minimal one of the given addresses is not reserved
 287      */
 288     protected function isReserved($host)
 289     {
 290         if (!preg_match('/^([0-9]{1,3}\.){3}[0-9]{1,3}$/', $host)) {
 291             $host = gethostbynamel($host);
 292         } else {
 293             $host = array($host);
 294         }
 295
 296         if (empty($host)) {
 297             return false;
 298         }
 299
 300         foreach ($host as $server) {
 301                 // Search for 0.0.0.0/8, 10.0.0.0/8, 127.0.0.0/8
 302             if (!preg_match('/^(0|10|127)(\.([0-9]|[1-9][0-9]|1([0-9][0-9])|2([0-4][0-9]|5[0-5]))){3}$/', $server) &&
 303                 // Search for 100.64.0.0/10
 304                 !preg_match('/^100\.(6[0-4]|[7-9][0-9]|1[0-1][0-9]|12[0-7])(\.([0-9]|[1-9][0-9]|1([0-9][0-9])|2([0-4][0-9]|5[0-5]))){2}$/', $server) &&
 305                 // Search for 172.16.0.0/12
 306                 !preg_match('/^172\.(1[6-9]|2[0-9]|3[0-1])(\.([0-9]|[1-9][0-9]|1([0-9][0-9])|2([0-4][0-9]|5[0-5]))){2}$/', $server) &&
 307                 // Search for 198.18.0.0/15
 308                 !preg_match('/^198\.(1[8-9])(\.([0-9]|[1-9][0-9]|1([0-9][0-9])|2([0-4][0-9]|5[0-5]))){2}$/', $server) &&
 309                 // Search for 169.254.0.0/16, 192.168.0.0/16
 310                 !preg_match('/^(169\.254|192\.168)(\.([0-9]|[1-9][0-9]|1([0-9][0-9])|2([0-4][0-9]|5[0-5]))){2}$/', $server) &&
 311                 // Search for 192.0.2.0/24, 192.88.99.0/24, 198.51.100.0/24, 203.0.113.0/24
 312                 !preg_match('/^(192\.0\.2|192\.88\.99|198\.51\.100|203\.0\.113)\.([0-9]|[1-9][0-9]|1([0-9][0-9])|2([0-4][0-9]|5[0-5]))$/', $server) &&
 313                 // Search for 224.0.0.0/4, 240.0.0.0/4
 314                 !preg_match('/^(2(2[4-9]|[3-4][0-9]|5[0-5]))(\.([0-9]|[1-9][0-9]|1([0-9][0-9])|2([0-4][0-9]|5[0-5]))){3}$/', $server)
 315             ) {
 316                 return false;
 317             }
 318         }
 319
 320         return true;
 321     }
 322
 323     /**
 324      * Internal method to validate the local part of the email address
 325      *
 326      * @return bool
 327      */
 328     protected function validateLocalPart()
 329     {
 330         // First try to match the local part on the common dot-atom format
 331         $result = false;
 332
 333         // Dot-atom characters are: 1*atext *("." 1*atext)
 334         // atext: ALPHA / DIGIT / and "!", "#", "$", "%", "&", "'", "*",
 335         //        "+", "-", "/", "=", "?", "^", "_", "`", "{", "|", "}", "~"
 336         $atext = 'a-zA-Z0-9\x21\x23\x24\x25\x26\x27\x2a\x2b\x2d\x2f\x3d\x3f\x5e\x5f\x60\x7b\x7c\x7d\x7e';
 337         if (preg_match('/^[' . $atext . ']+(\x2e+[' . $atext . ']+)*$/', $this->localPart)) {
 338             $result = true;
 339         } else {
 340             // Try quoted string format (RFC 5321 Chapter 4.1.2)
 341
 342             // Quoted-string characters are: DQUOTE *(qtext/quoted-pair) DQUOTE
 343             $qtext      = '\x20-\x21\x23-\x5b\x5d-\x7e'; // %d32-33 / %d35-91 / %d93-126
 344             $quotedPair = '\x20-\x7e'; // %d92 %d32-126
 345             if (preg_match('/^"(['. $qtext .']|\x5c[' . $quotedPair . '])*"$/', $this->localPart)) {
 346                 $result = true;
 347             } else {
 348                 $this->error(self::DOT_ATOM);
 349                 $this->error(self::QUOTED_STRING);
 350                 $this->error(self::INVALID_LOCAL_PART);
 351             }
 352         }
 353
 354         return $result;
 355     }
 356
 357     /**
 358      * Returns the found MX Record information after validation including weight for further processing
 359      *
 360      * @return array
 361      */
 362     public function getMXRecord()
 363     {
 364         return $this->mxRecord;
 365     }
 366
 367     /**
 368      * Internal method to validate the servers MX records
 369      *
 370      * @return bool
 371      */
 372     protected function validateMXRecords()
 373     {
 374         $mxHosts = array();
 375         $weight  = array();
 376         $result = getmxrr($this->hostname, $mxHosts, $weight);
 377         if (!empty($mxHosts) && !empty($weight)) {
 378             $this->mxRecord = array_combine($mxHosts, $weight);
 379         } else {
 380             $this->mxRecord = $mxHosts;
 381         }
 382
 383         arsort($this->mxRecord);
 384
 385         // Fallback to IPv4 hosts if no MX record found (RFC 2821 SS 5).
 386         if (!$result) {
 387             $result = gethostbynamel($this->hostname);
 388             if (is_array($result)) {
 389                 $this->mxRecord = array_flip($result);
 390             }
 391         }
 392
 393         if (!$result) {
 394             $this->error(self::INVALID_MX_RECORD);
 395             return $result;
 396         }
 397
 398         if (!$this->options['useDeepMxCheck']) {
 399             return $result;
 400         }
 401
 402         $validAddress = false;
 403         $reserved     = true;
 404         foreach ($this->mxRecord as $hostname => $weight) {
 405             $res = $this->isReserved($hostname);
 406             if (!$res) {
 407                 $reserved = false;
 408             }
 409
 410             if (!$res
 411                 && (checkdnsrr($hostname, "A")
 412                 || checkdnsrr($hostname, "AAAA")
 413                 || checkdnsrr($hostname, "A6"))
 414             ) {
 415                 $validAddress = true;
 416                 break;
 417             }
 418         }
 419
 420         if (!$validAddress) {
 421             $result = false;
 422             $error  = ($reserved) ? self::INVALID_SEGMENT : self::INVALID_MX_RECORD;
 423             $this->error($error);
 424         }
 425
 426         return $result;
 427     }
 428
 429     /**
 430      * Internal method to validate the hostname part of the email address
 431      *
 432      * @return bool
 433      */
 434     protected function validateHostnamePart()
 435     {
 436         $hostname = $this->getHostnameValidator()->setTranslator($this->getTranslator())
 437                          ->isValid($this->hostname);
 438         if (!$hostname) {
 439             $this->error(self::INVALID_HOSTNAME);
 440             // Get messages and errors from hostnameValidator
 441             foreach ($this->getHostnameValidator()->getMessages() as $code => $message) {
 442                 $this->abstractOptions['messages'][$code] = $message;
 443             }
 444         } elseif ($this->options['useMxCheck']) {
 445             // MX check on hostname
 446             $hostname = $this->validateMXRecords();
 447         }
 448
 449         return $hostname;
 450     }
 451
 452     /**
 453      * Splits the given value in hostname and local part of the email address
 454      *
 455      * @param string $value Email address to be split
 456      * @return bool Returns false when the email can not be split
 457      */
 458     protected function splitEmailParts($value)
 459     {
 460         // Split email address up and disallow '..'
 461         if ((strpos($value, '..') !== false) or
 462             (!preg_match('/^(.+)@([^@]+)$/', $value, $matches))) {
 463             return false;
 464         }
 465
 466         $this->localPart = $matches[1];
 467         $this->hostname  = $matches[2];
 468
 469         return true;
 470     }
 471
 472     /**
 473      * Defined by Zend\Validator\ValidatorInterface
 474      *
 475      * Returns true if and only if $value is a valid email address
 476      * according to RFC2822
 477      *
 478      * @link   http://www.ietf.org/rfc/rfc2822.txt RFC2822
 479      * @link   http://www.columbia.edu/kermit/ascii.html US-ASCII characters
 480      * @param  string $value
 481      * @return bool
 482      */
 483     public function isValid($value)
 484     {
 485         if (!is_string($value)) {
 486             $this->error(self::INVALID);
 487             return false;
 488         }
 489
 490         $length  = true;
 491         $this->setValue($value);
 492
 493         // Split email address up and disallow '..'
 494         if (!$this->splitEmailParts($value)) {
 495             $this->error(self::INVALID_FORMAT);
 496             return false;
 497         }
 498
 499         if ((strlen($this->localPart) > 64) || (strlen($this->hostname) > 255)) {
 500             $length = false;
 501             $this->error(self::LENGTH_EXCEEDED);
 502         }
 503
 504         // Match hostname part
 505         if ($this->options['useDomainCheck']) {
 506             $hostname = $this->validateHostnamePart();
 507         }
 508
 509         $local = $this->validateLocalPart();
 510
 511         // If both parts valid, return true
 512         if ($local && $length) {
 513             if (($this->options['useDomainCheck'] && $hostname) || !$this->options['useDomainCheck']) {
 514                 return true;
 515             }
 516         }
 517
 518         return false;
 519     }
 520 }