TYPO3_6-2/_rfc822_addresses_parser_8php_source.html

 <?php
 namespace TYPO3\CMS\Core\Mail;

 class Rfc822AddressesParser {

     private $address = '';

     private $default_domain = 'localhost';

     private $validate = TRUE;

     private $addresses = array();

     private $structure = array();

     private $error = NULL;

     private $index = NULL;

     private $num_groups = 0;

     private $limit = NULL;

     public function __construct($address = NULL, $default_domain = NULL, $validate = NULL, $limit = NULL) {
         if (isset($address)) {
             $this->address = $address;
         }
         if (isset($default_domain)) {
             $this->default_domain = $default_domain;
         }
         if (isset($validate)) {
             $this->validate = $validate;
         }
         if (isset($limit)) {
             $this->limit = $limit;
         }
     }

     public function parseAddressList($address = NULL, $default_domain = NULL, $validate = NULL, $limit = NULL) {
         if (isset($address)) {
             $this->address = $address;
         }
         if (isset($default_domain)) {
             $this->default_domain = $default_domain;
         }
         if (isset($validate)) {
             $this->validate = $validate;
         }
         if (isset($limit)) {
             $this->limit = $limit;
         }
         $this->structure = array();
         $this->addresses = array();
         $this->error = NULL;
         $this->index = NULL;
         // Unfold any long lines in $this->address.
         $this->address = preg_replace('/\\r?\\n/', '
 ', $this->address);
         $this->address = preg_replace('/\\r\\n(\\t| )+/', ' ', $this->address);
         while ($this->address = $this->_splitAddresses($this->address)) {

         }
         if ($this->address === FALSE || isset($this->error)) {
             throw new \InvalidArgumentException($this->error, 1294681466);
         }
         // Validate each address individually.  If we encounter an invalid
         // address, stop iterating and return an error immediately.
         foreach ($this->addresses as $address) {
             $valid = $this->_validateAddress($address);
             if ($valid === FALSE || isset($this->error)) {
                 throw new \InvalidArgumentException($this->error, 1294681467);
             }
             $this->structure = array_merge($this->structure, $valid);
         }
         return $this->structure;
     }

     protected function _splitAddresses($address) {
         if (!empty($this->limit) && count($this->addresses) == $this->limit) {
             return '';
         }
         if ($this->_isGroup($address) && !isset($this->error)) {
             $split_char = ';';
             $is_group = TRUE;
         } elseif (!isset($this->error)) {
             $split_char = ',';
             $is_group = FALSE;
         } elseif (isset($this->error)) {
             return FALSE;
         }
         // Split the string based on the above ten or so lines.
         $parts = explode($split_char, $address);
         $string = $this->_splitCheck($parts, $split_char);
         // If a group...
         if ($is_group) {
             // If $string does not contain a colon outside of
             // brackets/quotes etc then something's fubar.
             // First check there's a colon at all:
             if (strpos($string, ':') === FALSE) {
                 $this->error = 'Invalid address: ' . $string;
                 return FALSE;
             }
             // Now check it's outside of brackets/quotes:
             if (!$this->_splitCheck(explode(':', $string), ':')) {
                 return FALSE;
             }
             // We must have a group at this point, so increase the counter:
             $this->num_groups++;
         }
         // $string now contains the first full address/group.
         // Add to the addresses array.
         $this->addresses[] = array(
             'address' => trim($string),
             'group' => $is_group
         );
         // Remove the now stored address from the initial line, the +1
         // is to account for the explode character.
         $address = trim(substr($address, strlen($string) + 1));
         // If the next char is a comma and this was a group, then
         // there are more addresses, otherwise, if there are any more
         // chars, then there is another address.
         if ($is_group && $address[0] === ',') {
             $address = trim(substr($address, 1));
             return $address;
         } elseif (strlen($address) > 0) {
             return $address;
         } else {
             return '';
         }
     }

     protected function _isGroup($address) {
         // First comma not in quotes, angles or escaped:
         $parts = explode(',', $address);
         $string = $this->_splitCheck($parts, ',');
         // Now we have the first address, we can reliably check for a
         // group by searching for a colon that's not escaped or in
         // quotes or angle brackets.
         if (count(($parts = explode(':', $string))) > 1) {
             $string2 = $this->_splitCheck($parts, ':');
             return $string2 !== $string;
         } else {
             return FALSE;
         }
     }

     protected function _splitCheck($parts, $char) {
         $string = $parts[0];
         $partsCounter = count($parts);
         for ($i = 0; $i < $partsCounter; $i++) {
             if ($this->_hasUnclosedQuotes($string) || $this->_hasUnclosedBrackets($string, '<>') || $this->_hasUnclosedBrackets($string, '[]') || $this->_hasUnclosedBrackets($string, '()') || substr($string, -1) == '\\') {
                 if (isset($parts[$i + 1])) {
                     $string = $string . $char . $parts[($i + 1)];
                 } else {
                     $this->error = 'Invalid address spec. Unclosed bracket or quotes';
                     return FALSE;
                 }
             } else {
                 $this->index = $i;
                 break;
             }
         }
         return $string;
     }

     protected function _hasUnclosedQuotes($string) {
         $string = trim($string);
         $iMax = strlen($string);
         $in_quote = FALSE;
         $i = ($slashes = 0);
         for (; $i < $iMax; ++$i) {
             switch ($string[$i]) {
                 case '\\':
                     ++$slashes;
                     break;
                 case '"':
                     if ($slashes % 2 == 0) {
                         $in_quote = !$in_quote;
                     }
                 default:
                     $slashes = 0;
             }
         }
         return $in_quote;
     }

     protected function _hasUnclosedBrackets($string, $chars) {
         $num_angle_start = substr_count($string, $chars[0]);
         $num_angle_end = substr_count($string, $chars[1]);
         $this->_hasUnclosedBracketsSub($string, $num_angle_start, $chars[0]);
         $this->_hasUnclosedBracketsSub($string, $num_angle_end, $chars[1]);
         if ($num_angle_start < $num_angle_end) {
             $this->error = 'Invalid address spec. Unmatched quote or bracket (' . $chars . ')';
             return FALSE;
         } else {
             return $num_angle_start > $num_angle_end;
         }
     }

     protected function _hasUnclosedBracketsSub($string, &$num, $char) {
         $parts = explode($char, $string);
         $partsCounter = count($parts);
         for ($i = 0; $i < $partsCounter; $i++) {
             if (substr($parts[$i], -1) == '\\' || $this->_hasUnclosedQuotes($parts[$i])) {
                 $num--;
             }
             if (isset($parts[$i + 1])) {
                 $parts[$i + 1] = $parts[$i] . $char . $parts[($i + 1)];
             }
         }
         return $num;
     }

     protected function _validateAddress($address) {
         $is_group = FALSE;
         $addresses = array();
         if ($address['group']) {
             $is_group = TRUE;
             // Get the group part of the name
             $parts = explode(':', $address['address']);
             $groupname = $this->_splitCheck($parts, ':');
             $structure = array();
             // And validate the group part of the name.
             if (!$this->_validatePhrase($groupname)) {
                 $this->error = 'Group name did not validate.';
                 return FALSE;
             }
             $address['address'] = ltrim(substr($address['address'], strlen($groupname . ':')));
         }
         // If a group then split on comma and put into an array.
         // Otherwise, Just put the whole address in an array.
         if ($is_group) {
             while (strlen($address['address']) > 0) {
                 $parts = explode(',', $address['address']);
                 $addresses[] = $this->_splitCheck($parts, ',');
                 $address['address'] = trim(substr($address['address'], strlen(end($addresses) . ',')));
             }
         } else {
             $addresses[] = $address['address'];
         }
         // Check that $addresses is set, if address like this:
         // Groupname:;
         // Then errors were appearing.
         if (!count($addresses)) {
             $this->error = 'Empty group.';
             return FALSE;
         }
         // Trim the whitespace from all of the address strings.
         array_map('trim', $addresses);
         // Validate each mailbox.
         // Format could be one of: name <geezer@domain.com>
         //                         geezer@domain.com
         //                         geezer
         // ... or any other format valid by RFC 822.
         $addressesCount = count($addresses);
         for ($i = 0; $i < $addressesCount; $i++) {
             if (!$this->validateMailbox($addresses[$i])) {
                 if (empty($this->error)) {
                     $this->error = 'Validation failed for: ' . $addresses[$i];
                 }
                 return FALSE;
             }
         }
         if ($is_group) {
             $structure = array_merge($structure, $addresses);
         } else {
             $structure = $addresses;
         }
         return $structure;
     }

     protected function _validatePhrase($phrase) {
         // Splits on one or more Tab or space.
         $parts = preg_split('/[ \\x09]+/', $phrase, -1, PREG_SPLIT_NO_EMPTY);
         $phrase_parts = array();
         while (count($parts) > 0) {
             $phrase_parts[] = $this->_splitCheck($parts, ' ');
             for ($i = 0; $i < $this->index + 1; $i++) {
                 array_shift($parts);
             }
         }
         foreach ($phrase_parts as $part) {
             // If quoted string:
             if ($part[0] === '"') {
                 if (!$this->_validateQuotedString($part)) {
                     return FALSE;
                 }
                 continue;
             }
             // Otherwise it's an atom:
             if (!$this->_validateAtom($part)) {
                 return FALSE;
             }
         }
         return TRUE;
     }

     protected function _validateAtom($atom) {
         if (!$this->validate) {
             // Validation has been turned off; assume the atom is okay.
             return TRUE;
         }
         // Check for any char from ASCII 0 - ASCII 127
         if (!preg_match('/^[\\x00-\\x7E]+$/i', $atom, $matches)) {
             return FALSE;
         }
         // Check for specials:
         if (preg_match('/[][()<>@,;\\:". ]/', $atom)) {
             return FALSE;
         }
         // Check for control characters (ASCII 0-31):
         if (preg_match('/[\\x00-\\x1F]+/', $atom)) {
             return FALSE;
         }
         return TRUE;
     }

     protected function _validateQuotedString($qstring) {
         // Leading and trailing "
         $qstring = substr($qstring, 1, -1);
         // Perform check, removing quoted characters first.
         return !preg_match('/[\\x0D\\\\"]/', preg_replace('/\\\\./', '', $qstring));
     }

     protected function validateMailbox(&$mailbox) {
         // A couple of defaults.
         $phrase = '';
         $comment = '';
         $comments = array();
         // Catch any RFC822 comments and store them separately.
         $_mailbox = $mailbox;
         while (strlen(trim($_mailbox)) > 0) {
             $parts = explode('(', $_mailbox);
             $before_comment = $this->_splitCheck($parts, '(');
             if ($before_comment != $_mailbox) {
                 // First char should be a (.
                 $comment = substr(str_replace($before_comment, '', $_mailbox), 1);
                 $parts = explode(')', $comment);
                 $comment = $this->_splitCheck($parts, ')');
                 $comments[] = $comment;
                 // +2 is for the brackets
                 $_mailbox = substr($_mailbox, strpos($_mailbox, ('(' . $comment)) + strlen($comment) + 2);
             } else {
                 break;
             }
         }
         foreach ($comments as $comment) {
             $mailbox = str_replace('(' . $comment . ')', '', $mailbox);
         }
         $mailbox = trim($mailbox);
         // Check for name + route-addr
         if (substr($mailbox, -1) === '>' && $mailbox[0] !== '<') {
             $parts = explode('<', $mailbox);
             $name = $this->_splitCheck($parts, '<');
             $phrase = trim($name);
             $route_addr = trim(substr($mailbox, strlen($name . '<'), -1));
             if ($this->_validatePhrase($phrase) === FALSE || ($route_addr = $this->_validateRouteAddr($route_addr)) === FALSE) {
                 return FALSE;
             }
         } else {
             // First snip angle brackets if present.
             if ($mailbox[0] === '<' && substr($mailbox, -1) === '>') {
                 $addr_spec = substr($mailbox, 1, -1);
             } else {
                 $addr_spec = $mailbox;
             }
             if (($addr_spec = $this->_validateAddrSpec($addr_spec)) === FALSE) {
                 return FALSE;
             }
         }
         // Construct the object that will be returned.
         $mbox = new \stdClass();
         // Add the phrase (even if empty) and comments
         $mbox->personal = $phrase;
         $mbox->comment = isset($comments) ? $comments : array();
         if (isset($route_addr)) {
             $mbox->mailbox = $route_addr['local_part'];
             $mbox->host = $route_addr['domain'];
             $route_addr['adl'] !== '' ? ($mbox->adl = $route_addr['adl']) : '';
         } else {
             $mbox->mailbox = $addr_spec['local_part'];
             $mbox->host = $addr_spec['domain'];
         }
         $mailbox = $mbox;
         return TRUE;
     }

     protected function _validateRouteAddr($route_addr) {
         // Check for colon.
         if (strpos($route_addr, ':') !== FALSE) {
             $parts = explode(':', $route_addr);
             $route = $this->_splitCheck($parts, ':');
         } else {
             $route = $route_addr;
         }
         // If $route is same as $route_addr then the colon was in
         // quotes or brackets or, of course, non existent.
         if ($route === $route_addr) {
             unset($route);
             $addr_spec = $route_addr;
             if (($addr_spec = $this->_validateAddrSpec($addr_spec)) === FALSE) {
                 return FALSE;
             }
         } else {
             // Validate route part.
             if (($route = $this->_validateRoute($route)) === FALSE) {
                 return FALSE;
             }
             $addr_spec = substr($route_addr, strlen($route . ':'));
             // Validate addr-spec part.
             if (($addr_spec = $this->_validateAddrSpec($addr_spec)) === FALSE) {
                 return FALSE;
             }
         }
         if (isset($route)) {
             $return['adl'] = $route;
         } else {
             $return['adl'] = '';
         }
         $return = array_merge($return, $addr_spec);
         return $return;
     }

     protected function _validateRoute($route) {
         // Split on comma.
         $domains = explode(',', trim($route));
         foreach ($domains as $domain) {
             $domain = str_replace('@', '', trim($domain));
             if (!$this->_validateDomain($domain)) {
                 return FALSE;
             }
         }
         return $route;
     }

     protected function _validateDomain($domain) {
         // Note the different use of $subdomains and $sub_domains
         $subdomains = explode('.', $domain);
         while (count($subdomains) > 0) {
             $sub_domains[] = $this->_splitCheck($subdomains, '.');
             for ($i = 0; $i < $this->index + 1; $i++) {
                 array_shift($subdomains);
             }
         }
         foreach ($sub_domains as $sub_domain) {
             if (!$this->_validateSubdomain(trim($sub_domain))) {
                 return FALSE;
             }
         }
         // Managed to get here, so return input.
         return $domain;
     }

     protected function _validateSubdomain($subdomain) {
         if (preg_match('|^\\[(.*)]$|', $subdomain, $arr)) {
             if (!$this->_validateDliteral($arr[1])) {
                 return FALSE;
             }
         } else {
             if (!$this->_validateAtom($subdomain)) {
                 return FALSE;
             }
         }
         // Got here, so return successful.
         return TRUE;
     }

     protected function _validateDliteral($dliteral) {
         return !preg_match('/(.)[][\\x0D\\\\]/', $dliteral, $matches) && $matches[1] != '\\';
     }

     protected function _validateAddrSpec($addr_spec) {
         $addr_spec = trim($addr_spec);
         // Split on @ sign if there is one.
         if (strpos($addr_spec, '@') !== FALSE) {
             $parts = explode('@', $addr_spec);
             $local_part = $this->_splitCheck($parts, '@');
             $domain = substr($addr_spec, strlen($local_part . '@'));
         } else {
             $local_part = $addr_spec;
             $domain = $this->default_domain;
         }
         if (($local_part = $this->_validateLocalPart($local_part)) === FALSE) {
             return FALSE;
         }
         if (($domain = $this->_validateDomain($domain)) === FALSE) {
             return FALSE;
         }
         // Got here so return successful.
         return array('local_part' => $local_part, 'domain' => $domain);
     }

     protected function _validateLocalPart($local_part) {
         $parts = explode('.', $local_part);
         $words = array();
         // Split the local_part into words.
         while (count($parts) > 0) {
             $words[] = $this->_splitCheck($parts, '.');
             for ($i = 0; $i < $this->index + 1; $i++) {
                 array_shift($parts);
             }
         }
         // Validate each word.
         foreach ($words as $word) {
             // If this word contains an unquoted space, it is invalid. (6.2.4)
             if (strpos($word, ' ') && $word[0] !== '"') {
                 return FALSE;
             }
             if ($this->_validatePhrase(trim($word)) === FALSE) {
                 return FALSE;
             }
         }
         // Managed to get here, so return the input.
         return $local_part;
     }

 }
TYPO3\CMS\Core\Mail\Rfc822AddressesParser\__construct
__construct($address=NULL, $default_domain=NULL, $validate=NULL, $limit=NULL)
Definition: Rfc822AddressesParser.php:144

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateDliteral
_validateDliteral($dliteral)
Definition: Rfc822AddressesParser.php:735

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_hasUnclosedQuotes
_hasUnclosedQuotes($string)
Definition: Rfc822AddressesParser.php:326

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_hasUnclosedBracketsSub
_hasUnclosedBracketsSub($string, &$num, $char)
Definition: Rfc822AddressesParser.php:378

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateAtom
_validateAtom($atom)
Definition: Rfc822AddressesParser.php:503

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateLocalPart
_validateLocalPart($local_part)
Definition: Rfc822AddressesParser.php:777

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$limit
$limit
Definition: Rfc822AddressesParser.php:134

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_isGroup
_isGroup($address)
Definition: Rfc822AddressesParser.php:277

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\validateMailbox
validateMailbox(&$mailbox)
Definition: Rfc822AddressesParser.php:547

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$default_domain
$default_domain
Definition: Rfc822AddressesParser.php:84

TYPO3\CMS\Core\Mail\Rfc822AddressesParser
Definition: Rfc822AddressesParser.php:70

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$addresses
$addresses
Definition: Rfc822AddressesParser.php:98

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\parseAddressList
parseAddressList($address=NULL, $default_domain=NULL, $validate=NULL, $limit=NULL)
Definition: Rfc822AddressesParser.php:170

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateRoute
_validateRoute($route)
Definition: Rfc822AddressesParser.php:665

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$structure
$structure
Definition: Rfc822AddressesParser.php:105

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateDomain
_validateDomain($domain)
Definition: Rfc822AddressesParser.php:687

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_hasUnclosedBrackets
_hasUnclosedBrackets($string, $chars)
Definition: Rfc822AddressesParser.php:356

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateSubdomain
_validateSubdomain($subdomain)
Definition: Rfc822AddressesParser.php:713

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$validate
$validate
Definition: Rfc822AddressesParser.php:91

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$num_groups
$num_groups
Definition: Rfc822AddressesParser.php:127

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$address
$address
Definition: Rfc822AddressesParser.php:77

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateQuotedString
_validateQuotedString($qstring)
Definition: Rfc822AddressesParser.php:531

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_splitAddresses
_splitAddresses($address)
Definition: Rfc822AddressesParser.php:216

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateAddress
_validateAddress($address)
Definition: Rfc822AddressesParser.php:399

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validatePhrase
_validatePhrase($phrase)
Definition: Rfc822AddressesParser.php:464

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateRouteAddr
_validateRouteAddr($route_addr)
Definition: Rfc822AddressesParser.php:621

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_splitCheck
_splitCheck($parts, $char)
Definition: Rfc822AddressesParser.php:300

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$error
$error
Definition: Rfc822AddressesParser.php:112

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\$index
$index
Definition: Rfc822AddressesParser.php:119

TYPO3\CMS\Core\Mail
Definition: Mailer.php:2

TYPO3\CMS\Core\Mail\Rfc822AddressesParser\_validateAddrSpec
_validateAddrSpec($addr_spec)
Definition: Rfc822AddressesParser.php:748