├── version.txt
├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── tests.yml
├── PHPStanConstants.php
├── phpstan.neon
├── .php-cs-fixer.dist.php
├── src
    ├── Message
    │   ├── Factory
    │   │   ├── PartChildrenContainerFactory.php
    │   │   ├── IUUEncodedPartFactory.php
    │   │   ├── PartHeaderContainerFactory.php
    │   │   ├── IMessagePartFactory.php
    │   │   ├── PartStreamContainerFactory.php
    │   │   └── IMimePartFactory.php
    │   ├── Helper
    │   │   └── AbstractHelper.php
    │   ├── IUUEncodedPart.php
    │   ├── NonMimePart.php
    │   ├── UUEncodedPart.php
    │   └── PartFilter.php
    ├── Parser
    │   ├── Part
    │   │   ├── ParserPartChildrenContainerFactory.php
    │   │   ├── UUEncodedPartHeaderContainerFactory.php
    │   │   ├── ParserPartChildrenContainer.php
    │   │   ├── ParserPartStreamContainerFactory.php
    │   │   └── UUEncodedPartHeaderContainer.php
    │   ├── CompatibleParserNotFoundException.php
    │   ├── Proxy
    │   │   ├── ParserPartProxyFactory.php
    │   │   ├── ParserMessageProxy.php
    │   │   ├── ParserNonMimeMessageProxyFactory.php
    │   │   ├── ParserUUEncodedPartProxyFactory.php
    │   │   ├── ParserMessageProxyFactory.php
    │   │   ├── ParserMimePartProxyFactory.php
    │   │   ├── ParserNonMimeMessageProxy.php
    │   │   └── ParserUUEncodedPartProxy.php
    │   ├── PartBuilderFactory.php
    │   ├── HeaderParserService.php
    │   ├── AbstractParserService.php
    │   ├── MessageParserService.php
    │   ├── ParserManagerService.php
    │   ├── IParserService.php
    │   └── NonMimeParserService.php
    ├── Header
    │   ├── Part
    │   │   ├── MimeTokenPartFactory.php
    │   │   ├── ReceivedPart.php
    │   │   ├── SubjectToken.php
    │   │   ├── QuotedLiteralPart.php
    │   │   ├── AddressPart.php
    │   │   ├── NameValuePart.php
    │   │   ├── Token.php
    │   │   ├── CommentPart.php
    │   │   ├── DatePart.php
    │   │   ├── AddressGroupPart.php
    │   │   ├── SplitParameterPart.php
    │   │   ├── MimeToken.php
    │   │   ├── ReceivedDomainPart.php
    │   │   ├── HeaderPart.php
    │   │   ├── ParameterPart.php
    │   │   └── ContainerPart.php
    │   ├── Consumer
    │   │   ├── IConsumerService.php
    │   │   ├── GenericConsumerMimeLiteralPartService.php
    │   │   ├── GenericConsumerService.php
    │   │   ├── QuotedStringMimeLiteralPartConsumerService.php
    │   │   ├── Received
    │   │   │   ├── ReceivedDateConsumerService.php
    │   │   │   ├── DomainConsumerService.php
    │   │   │   └── GenericReceivedConsumerService.php
    │   │   ├── QuotedStringMimeLiteralPartTokenSplitPatternTrait.php
    │   │   ├── DateConsumerService.php
    │   │   ├── IdConsumerService.php
    │   │   ├── ParameterValueConsumerService.php
    │   │   ├── AbstractGenericConsumerService.php
    │   │   ├── SubjectConsumerService.php
    │   │   ├── QuotedStringConsumerService.php
    │   │   ├── AddressEmailConsumerService.php
    │   │   ├── IdBaseConsumerService.php
    │   │   ├── AddressBaseConsumerService.php
    │   │   ├── ParameterNameValueConsumerService.php
    │   │   ├── AddressGroupConsumerService.php
    │   │   ├── ParameterConsumerService.php
    │   │   ├── CommentConsumerService.php
    │   │   └── ReceivedConsumerService.php
    │   ├── IHeaderPart.php
    │   ├── SubjectHeader.php
    │   ├── GenericHeader.php
    │   ├── DateHeader.php
    │   ├── IdHeader.php
    │   ├── MimeEncodedHeader.php
    │   ├── HeaderConsts.php
    │   ├── IHeader.php
    │   ├── ParameterHeader.php
    │   └── AddressHeader.php
    ├── Stream
    │   ├── MessagePartStreamReadException.php
    │   ├── MessagePartStreamDecorator.php
    │   └── HeaderStream.php
    ├── IErrorBag.php
    ├── Error.php
    ├── di_config.php
    └── ErrorBag.php
├── LICENSE
└── composer.json


/version.txt:
--------------------------------------------------------------------------------
1 | 3.0.4
2 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 | 
3 | github: zbateson
4 | 


--------------------------------------------------------------------------------
/PHPStanConstants.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | define ('TEST_DATA_DIR', __DIR__ . '/tests/_data');
4 | define ('TEST_OUTPUT_DIR', __DIR__ . '/tests/_output');
5 | 


--------------------------------------------------------------------------------
/phpstan.neon:
--------------------------------------------------------------------------------
 1 | parameters:
 2 | 	level: 6
 3 | 	errorFormat: raw
 4 | 	editorUrl: '%%file%% %%line%% %%column%%: %%error%%'
 5 | 	paths:
 6 | 		- src
 7 | 	bootstrapFiles:
 8 | 		- PHPStanConstants.php
 9 | 	ignoreErrors:
10 | 		-
11 | 			message: '#Call to an undefined method ZBateson\\MailMimeParser#'
12 | 			paths:
13 | 				- src/*
14 | 


--------------------------------------------------------------------------------
/.php-cs-fixer.dist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  * This document has been generated with
 4 |  * https://mlocati.github.io/php-cs-fixer-configurator/#version:3.0.0-rc.1|configurator
 5 |  * you can change this configuration by importing this file.
 6 |  *
 7 |  */
 8 | 
 9 | $config = include 'vendor/zbateson/mb-wrapper/PhpCsFixer.php';
10 | 
11 | return $config->setFinder(PhpCsFixer\Finder::create()
12 |     ->exclude('vendor')
13 |     ->in(__DIR__.'/src')
14 |     ->in(__DIR__.'/tests')
15 |     );
16 | 


--------------------------------------------------------------------------------
/src/Message/Factory/PartChildrenContainerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message\Factory;
 9 | 
10 | use ZBateson\MailMimeParser\Message\PartChildrenContainer;
11 | 
12 | /**
13 |  * Creates PartChildrenContainer instances.
14 |  *
15 |  * @author Zaahid Bateson
16 |  */
17 | class PartChildrenContainerFactory
18 | {
19 |     public function newInstance() : PartChildrenContainer
20 |     {
21 |         return new PartChildrenContainer();
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Parser/Part/ParserPartChildrenContainerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Part;
 9 | 
10 | use ZBateson\MailMimeParser\Parser\Proxy\ParserMimePartProxy;
11 | 
12 | /**
13 |  * Creates ParserPartChildrenContainer instances.
14 |  *
15 |  * @author Zaahid Bateson
16 |  */
17 | class ParserPartChildrenContainerFactory
18 | {
19 |     public function newInstance(ParserMimePartProxy $parserProxy) : ParserPartChildrenContainer
20 |     {
21 |         return new ParserPartChildrenContainer($parserProxy);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Parser/CompatibleParserNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser;
 9 | 
10 | use RuntimeException;
11 | 
12 | /**
13 |  * Exception thrown if the ParserManagerService doesn't contain a parser that
14 |  * can handle a given type of part.  The default configuration of MailMimeParser
15 |  * uses NonMimeParserService that is a 'catch-all', so this would indicate a
16 |  * configuration error.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class CompatibleParserNotFoundException extends RuntimeException
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Header/Part/MimeTokenPartFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use ZBateson\MailMimeParser\Header\IHeaderPart;
11 | 
12 | /**
13 |  * Extends HeaderPartFactory to instantiate MimeTokens for its
14 |  * newInstance method.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | class MimeTokenPartFactory extends HeaderPartFactory
19 | {
20 |     /**
21 |      * Creates and returns a MimeToken.
22 |      */
23 |     public function newInstance(string $value) : IHeaderPart
24 |     {
25 |         return $this->newMimeToken($value);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/IConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the ZBateson\MailMimeParser project.
 5 |  *
 6 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 7 |  */
 8 | 
 9 | namespace ZBateson\MailMimeParser\Header\Consumer;
10 | 
11 | /**
12 |  * Interface defining a consumer service class.
13 |  *
14 |  * @author Zaahid Bateson
15 |  */
16 | interface IConsumerService
17 | {
18 |     /**
19 |      * Invokes parsing of a header's value into header parts.
20 |      *
21 |      * @param string $value the raw header value
22 |      * @return \ZBateson\MailMimeParser\Header\IHeaderPart[] the array of parsed
23 |      *         parts
24 |      */
25 |     public function __invoke(string $value) : array;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserPartProxyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Proxy;
 9 | 
10 | use ZBateson\MailMimeParser\Parser\IParserService;
11 | use ZBateson\MailMimeParser\Parser\PartBuilder;
12 | 
13 | /**
14 |  * Base class for factories creating ParserPartProxy classes.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | abstract class ParserPartProxyFactory
19 | {
20 |     /**
21 |      * Constructs a new ParserPartProxy wrapping an IMessagePart object.
22 |      *
23 |      */
24 |     abstract public function newInstance(PartBuilder $partBuilder, IParserService $parser) : ParserPartProxy;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Header/IHeaderPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | use Stringable;
11 | use ZBateson\MailMimeParser\IErrorBag;
12 | 
13 | /**
14 |  * Represents a single parsed part of a header line's value.
15 |  *
16 |  * For header values with multiple parts, for instance a list of addresses, each
17 |  * address would be parsed into a single part.
18 |  *
19 |  * @author Zaahid Bateson
20 |  */
21 | interface IHeaderPart extends IErrorBag, Stringable
22 | {
23 |     /**
24 |      * Returns the part's value.
25 |      *
26 |      * @return string The value of the part
27 |      */
28 |     public function getValue() : ?string;
29 | 
30 |     /**
31 |      * Returns any CommentParts under this part container.
32 |      *
33 |      * @return CommentPart[]
34 |      */
35 |     public function getComments() : array;
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Header/Part/ReceivedPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MbWrapper\MbWrapper;
12 | 
13 | /**
14 |  * Represents one parameter in a parsed 'Received' header, e.g. the FROM or VIA
15 |  * part.
16 |  *
17 |  * Note that FROM and BY actually get parsed into a sub-class,
18 |  * ReceivedDomainPart which keeps track of other sub-parts that can be parsed
19 |  * from them.
20 |  *
21 |  * @author Zaahid Bateson
22 |  */
23 | class ReceivedPart extends NameValuePart
24 | {
25 |     /**
26 |      * @param HeaderPart[] $children
27 |      */
28 |     public function __construct(
29 |         LoggerInterface $logger,
30 |         MbWrapper $charsetConverter,
31 |         string $name,
32 |         array $children
33 |     ) {
34 |         parent::__construct($logger, $charsetConverter, [], $children);
35 |         $this->name = $name;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Stream/MessagePartStreamReadException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Stream;
 9 | 
10 | use RuntimeException;
11 | use ZBateson\MailMimeParser\Message\IMessagePart;
12 | 
13 | /**
14 |  * Thrown for exceptions on MessagePartStream::read so a $part can be used to
15 |  * determine where the exception occurred.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class MessagePartStreamReadException extends RuntimeException
20 | {
21 |     /**
22 |      * @var IMessagePart the IMessagePart the error was caused on.
23 |      */
24 |     protected IMessagePart $part;
25 | 
26 |     public function __construct(IMessagePart $part, string $message = '', int $code = 0, ?\Throwable $previous = null)
27 |     {
28 |         parent::__construct($message, $code, $previous);
29 |         $this->part = $part;
30 |     }
31 | 
32 |     public function getPart() : IMessagePart
33 |     {
34 |         return $this->part;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/GenericConsumerMimeLiteralPartService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Part\MimeTokenPartFactory;
12 | 
13 | /**
14 |  * GenericConsumerMimeLiteralPartService uses a MimeTokenPartFactory instead
15 |  * of a HeaderPartFactory.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class GenericConsumerMimeLiteralPartService extends GenericConsumerService
20 | {
21 |     public function __construct(
22 |         LoggerInterface $logger,
23 |         MimeTokenPartFactory $partFactory,
24 |         CommentConsumerService $commentConsumerService,
25 |         QuotedStringConsumerService $quotedStringConsumerService
26 |     ) {
27 |         parent::__construct(
28 |             $logger,
29 |             $partFactory,
30 |             $commentConsumerService,
31 |             $quotedStringConsumerService
32 |         );
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/GenericConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
12 | 
13 | /**
14 |  * The base GenericConsumerService is a consumer with CommentConsumerService and
15 |  * QuotedStringConsumerService as sub-consumers, and splitting tokens by
16 |  * whitespace.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class GenericConsumerService extends AbstractGenericConsumerService
21 | {
22 |     public function __construct(
23 |         LoggerInterface $logger,
24 |         HeaderPartFactory $partFactory,
25 |         CommentConsumerService $commentConsumerService,
26 |         QuotedStringConsumerService $quotedStringConsumerService
27 |     ) {
28 |         parent::__construct(
29 |             $logger,
30 |             $partFactory,
31 |             [$commentConsumerService, $quotedStringConsumerService]
32 |         );
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Message/Helper/AbstractHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message\Helper;
 9 | 
10 | use ZBateson\MailMimeParser\Message\Factory\IMimePartFactory;
11 | use ZBateson\MailMimeParser\Message\Factory\IUUEncodedPartFactory;
12 | 
13 | /**
14 |  * Base class for message helpers.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | abstract class AbstractHelper
19 | {
20 |     /**
21 |      * @var IMimePartFactory to create parts for attachments/content
22 |      */
23 |     protected IMimePartFactory $mimePartFactory;
24 | 
25 |     /**
26 |      * @var IUUEncodedPartFactory to create parts for attachments
27 |      */
28 |     protected IUUEncodedPartFactory $uuEncodedPartFactory;
29 | 
30 |     public function __construct(
31 |         IMimePartFactory $mimePartFactory,
32 |         IUUEncodedPartFactory $uuEncodedPartFactory
33 |     ) {
34 |         $this->mimePartFactory = $mimePartFactory;
35 |         $this->uuEncodedPartFactory = $uuEncodedPartFactory;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Header/SubjectHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Consumer\SubjectConsumerService;
12 | use ZBateson\MailMimeParser\MailMimeParser;
13 | 
14 | /**
15 |  * Reads a subject header.
16 |  *
17 |  * The subject header is unique in that it doesn't include comments or quoted
18 |  * parts.
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | class SubjectHeader extends AbstractHeader
23 | {
24 |     public function __construct(
25 |         string $name,
26 |         string $value,
27 |         ?LoggerInterface $logger = null,
28 |         ?SubjectConsumerService $consumerService = null
29 |     ) {
30 |         $di = MailMimeParser::getGlobalContainer();
31 |         parent::__construct(
32 |             $logger ?? $di->get(LoggerInterface::class),
33 |             $consumerService ?? $di->get(SubjectConsumerService::class),
34 |             $name,
35 |             $value
36 |         );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserMessageProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Proxy;
 9 | 
10 | /**
11 |  * A bi-directional parser-to-part proxy for IMessage objects created by
12 |  * MimeParser.
13 |  *
14 |  * @author Zaahid Bateson
15 |  */
16 | class ParserMessageProxy extends ParserMimePartProxy
17 | {
18 |     /**
19 |      * @var int maintains the character length of the last line separator,
20 |      *      typically 2 for CRLF, to keep track of the correct 'end' position
21 |      *      for a part because the CRLF before a boundary is considered part of
22 |      *      the boundary.
23 |      */
24 |     protected int $lastLineEndingLength = 0;
25 | 
26 |     public function getLastLineEndingLength() : int
27 |     {
28 |         return $this->lastLineEndingLength;
29 |     }
30 | 
31 |     public function setLastLineEndingLength(int $lastLineEndingLength) : static
32 |     {
33 |         $this->lastLineEndingLength = $lastLineEndingLength;
34 |         return $this;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/QuotedStringMimeLiteralPartConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use ZBateson\MailMimeParser\Header\IHeaderPart;
11 | use ZBateson\MailMimeParser\Header\Part\MimeToken;
12 | 
13 | /**
14 |  * Allows for mime-encoded parts inside a quoted part.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | class QuotedStringMimeLiteralPartConsumerService extends QuotedStringConsumerService
19 | {
20 |     /**
21 |      * Constructs a LiteralPart and returns it.
22 |      *
23 |      * @param bool $isLiteral not used - everything in a quoted string is a
24 |      *        literal
25 |      */
26 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
27 |     {
28 |         if (!$isLiteral && \preg_match('/' . MimeToken::MIME_PART_PATTERN . '/', $token)) {
29 |             return $this->partFactory->newMimeToken($token);
30 |         }
31 |         return $this->partFactory->newToken($token, $isLiteral);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/Received/ReceivedDateConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer\Received;
 9 | 
10 | use ZBateson\MailMimeParser\Header\Consumer\DateConsumerService;
11 | 
12 | /**
13 |  * Parses the date portion of a Received header into a DatePart.
14 |  *
15 |  * The only difference between DateConsumerService and
16 |  * ReceivedDateConsumerService is the addition of a start token, ';', and a
17 |  * token separator (also ';').
18 |  *
19 |  * @author Zaahid Bateson
20 |  */
21 | class ReceivedDateConsumerService extends DateConsumerService
22 | {
23 |     /**
24 |      * Returns true if the token is a ';'
25 |      */
26 |     protected function isStartToken(string $token) : bool
27 |     {
28 |         return ($token === ';');
29 |     }
30 | 
31 |     /**
32 |      * Returns an array containing ';'.
33 |      *
34 |      * @return string[] an array of regex pattern matchers
35 |      */
36 |     protected function getTokenSeparators() : array
37 |     {
38 |         return [';'];
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Message/Factory/IUUEncodedPartFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message\Factory;
 9 | 
10 | use ZBateson\MailMimeParser\Message\IMimePart;
11 | use ZBateson\MailMimeParser\Message\IUUEncodedPart;
12 | use ZBateson\MailMimeParser\Message\UUEncodedPart;
13 | 
14 | /**
15 |  * Responsible for creating UUEncodedPart instances.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class IUUEncodedPartFactory extends IMessagePartFactory
20 | {
21 |     /**
22 |      * Constructs a new UUEncodedPart object and returns it
23 |      */
24 |     public function newInstance(?IMimePart $parent = null) : IUUEncodedPart
25 |     {
26 |         $streamContainer = $this->partStreamContainerFactory->newInstance();
27 |         $part = new UUEncodedPart(
28 |             null,
29 |             null,
30 |             $parent,
31 |             $this->logger,
32 |             $streamContainer
33 |         );
34 |         $streamContainer->setStream($this->streamFactory->newMessagePartStream($part));
35 |         return $part;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/.github/workflows/tests.yml:
--------------------------------------------------------------------------------
 1 | name: Tests
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | jobs:
 6 |   test:
 7 |     runs-on: ${{ matrix.os }}
 8 |     strategy:
 9 |       fail-fast: false
10 |       matrix:
11 |         os: [ubuntu-latest, windows-latest]
12 |         php: [8.5, 8.4, 8.3, 8.2, 8.1, 8.0]
13 |         stability: [prefer-stable]
14 | 
15 |     name: P${{ matrix.php }} - ${{ matrix.stability }} - ${{ matrix.os }}
16 | 
17 |     steps:
18 |       - name: Checkout code
19 |         uses: actions/checkout@v2
20 | 
21 |       - name: Setup PHP
22 |         uses: shivammathur/setup-php@v2
23 |         with:
24 |           php-version: ${{ matrix.php }}
25 |           extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite, pdo_sqlite, bcmath, soap, intl, gd, exif, iconv, imagick, fileinfo
26 |           coverage: none
27 | 
28 |       - name: Setup problem matchers
29 |         run: |
30 |           echo "::add-matcher::${{ runner.tool_cache }}/php.json"
31 |           echo "::add-matcher::${{ runner.tool_cache }}/phpunit.json"
32 |       - name: Install dependencies
33 |         run: composer update --${{ matrix.stability }} --prefer-dist --no-interaction
34 | 
35 |       - name: Execute tests
36 |         run: ./vendor/bin/phpunit -c tests/phpunit.xml
37 | 


--------------------------------------------------------------------------------
/src/Parser/PartBuilderFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser;
 9 | 
10 | use Psr\Http\Message\StreamInterface;
11 | use ZBateson\MailMimeParser\Message\PartHeaderContainer;
12 | use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxy;
13 | 
14 | /**
15 |  * Responsible for creating PartBuilder instances.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class PartBuilderFactory
20 | {
21 |     /**
22 |      * Constructs a top-level (message) PartBuilder object and returns it.
23 |      */
24 |     public function newPartBuilder(PartHeaderContainer $headerContainer, StreamInterface $messageStream) : PartBuilder
25 |     {
26 |         return new PartBuilder($headerContainer, $messageStream);
27 |     }
28 | 
29 |     /**
30 |      * Constructs a child PartBuilder object with the passed $parent as its
31 |      * parent, and returns it.
32 |      */
33 |     public function newChildPartBuilder(PartHeaderContainer $headerContainer, ParserPartProxy $parent) : PartBuilder
34 |     {
35 |         return new PartBuilder(
36 |             $headerContainer,
37 |             null,
38 |             $parent
39 |         );
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Message/Factory/PartHeaderContainerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message\Factory;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\HeaderFactory;
12 | use ZBateson\MailMimeParser\Message\PartHeaderContainer;
13 | 
14 | /**
15 |  * Creates PartHeaderContainer instances.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class PartHeaderContainerFactory
20 | {
21 |     protected LoggerInterface $logger;
22 | 
23 |     /**
24 |      * @var HeaderFactory the HeaderFactory passed to HeaderContainer instances.
25 |      */
26 |     protected HeaderFactory $headerFactory;
27 | 
28 |     /**
29 |      * Constructor
30 |      *
31 |      */
32 |     public function __construct(LoggerInterface $logger, HeaderFactory $headerFactory)
33 |     {
34 |         $this->logger = $logger;
35 |         $this->headerFactory = $headerFactory;
36 |     }
37 | 
38 |     /**
39 |      * Creates and returns a PartHeaderContainer.
40 |      */
41 |     public function newInstance(?PartHeaderContainer $from = null) : PartHeaderContainer
42 |     {
43 |         return new PartHeaderContainer($this->logger, $this->headerFactory, $from);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Message/Factory/IMessagePartFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message\Factory;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Message\IMessagePart;
12 | use ZBateson\MailMimeParser\Message\IMimePart;
13 | use ZBateson\MailMimeParser\Stream\StreamFactory;
14 | 
15 | /**
16 |  * Abstract factory for subclasses of IMessagePart.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | abstract class IMessagePartFactory
21 | {
22 |     protected LoggerInterface $logger;
23 | 
24 |     protected StreamFactory $streamFactory;
25 | 
26 |     protected PartStreamContainerFactory $partStreamContainerFactory;
27 | 
28 |     public function __construct(
29 |         LoggerInterface $logger,
30 |         StreamFactory $streamFactory,
31 |         PartStreamContainerFactory $partStreamContainerFactory
32 |     ) {
33 |         $this->logger = $logger;
34 |         $this->streamFactory = $streamFactory;
35 |         $this->partStreamContainerFactory = $partStreamContainerFactory;
36 |     }
37 | 
38 |     /**
39 |      * Constructs a new IMessagePart object and returns it
40 |      */
41 |     abstract public function newInstance(?IMimePart $parent = null) : IMessagePart;
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Header/Part/SubjectToken.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MbWrapper\MbWrapper;
12 | 
13 | /**
14 |  * Specialized token for subjects that preserves whitespace, except for new
15 |  * lines.
16 |  *
17 |  * New lines are either discarded if followed by a whitespace as should happen
18 |  * with folding whitespace, or replaced by a single space character if somehow
19 |  * aren't followed by whitespace.
20 |  *
21 |  * @author Zaahid Bateson
22 |  */
23 | class SubjectToken extends Token
24 | {
25 |     public function __construct(
26 |         LoggerInterface $logger,
27 |         MbWrapper $charsetConverter,
28 |         string $value
29 |     ) {
30 |         parent::__construct($logger, $charsetConverter, $value, true);
31 |         $this->value = \preg_replace(['/(\r|\n)+(\s)\s*/', '/(\r|\n)+/'], ['$2', ' '], $value);
32 |         $this->isSpace = (\preg_match('/^\s*$/m', $this->value) === 1);
33 |         $this->canIgnoreSpacesBefore = $this->canIgnoreSpacesAfter = $this->isSpace;
34 |     }
35 | 
36 |     public function getValue() : string
37 |     {
38 |         return $this->convertEncoding($this->value);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2014-2015, Zaahid Bateson
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | * Redistributions of source code must retain the above copyright notice, this
 8 |   list of conditions and the following disclaimer.
 9 | 
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 |   this list of conditions and the following disclaimer in the documentation
12 |   and/or other materials provided with the distribution.
13 | 
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | 
25 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/QuotedStringMimeLiteralPartTokenSplitPatternTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use ZBateson\MailMimeParser\Header\Part\MimeToken;
11 | 
12 | /**
13 |  * Provides a getTokenSplitPattern for consumers that could have quoted parts
14 |  * that are mime-header-encoded.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | trait QuotedStringMimeLiteralPartTokenSplitPatternTrait
19 | {
20 |     /**
21 |      * Overridden to use a specialized regex for finding mime-encoded parts
22 |      * (RFC 2047).
23 |      *
24 |      * Some implementations seem to place mime-encoded parts within quoted
25 |      * parameters, and split the mime-encoded parts across multiple split
26 |      * parameters.  The specialized regex doesn't allow double quotes inside a
27 |      * mime encoded part, so it can be "continued" in another parameter.
28 |      *
29 |      * @return string the regex pattern
30 |      */
31 |     protected function getTokenSplitPattern() : string
32 |     {
33 |         $sChars = \implode('|', $this->getAllTokenSeparators());
34 |         $mimePartPattern = MimeToken::MIME_PART_PATTERN_NO_QUOTES;
35 |         return '~(' . $mimePartPattern . '|\\\\\r\n|\\\\.|' . $sChars . ')~ms';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Parser/Part/UUEncodedPartHeaderContainerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\HeaderFactory;
12 | 
13 | /**
14 |  * Creates UUEncodedPartHeaderContainer instances.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | class UUEncodedPartHeaderContainerFactory
19 | {
20 |     protected LoggerInterface $logger;
21 | 
22 |     /**
23 |      * @var HeaderFactory the HeaderFactory passed to
24 |      *      UUEncodedPartHeaderContainer instances.
25 |      */
26 |     protected HeaderFactory $headerFactory;
27 | 
28 |     /**
29 |      * Constructor
30 |      *
31 |      */
32 |     public function __construct(LoggerInterface $logger, HeaderFactory $headerFactory)
33 |     {
34 |         $this->logger = $logger;
35 |         $this->headerFactory = $headerFactory;
36 |     }
37 | 
38 |     /**
39 |      * Creates and returns a UUEncodedPartHeaderContainer.
40 |      */
41 |     public function newInstance(int $mode, string $filename) : UUEncodedPartHeaderContainer
42 |     {
43 |         $container = new UUEncodedPartHeaderContainer($this->logger, $this->headerFactory);
44 |         $container->setUnixFileMode($mode);
45 |         $container->setFilename($filename);
46 |         return $container;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/DateConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use ZBateson\MailMimeParser\Header\IHeaderPart;
11 | 
12 | /**
13 |  * Parses a date header into a Part\DatePart taking care of comment and quoted
14 |  * parts as necessary.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | class DateConsumerService extends GenericConsumerService
19 | {
20 |     /**
21 |      * Returns a Part\LiteralPart for the current token
22 |      *
23 |      * @param string $token the token
24 |      * @param bool $isLiteral set to true if the token represents a literal -
25 |      *        e.g. an escaped token
26 |      */
27 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
28 |     {
29 |         return $this->partFactory->newToken($token, false);
30 |     }
31 | 
32 |     /**
33 |      * Constructs a single Part\DatePart of any parsed parts returning it in an
34 |      * array with a single element.
35 |      *
36 |      * @param \ZBateson\MailMimeParser\Header\IHeaderPart[] $parts The parsed
37 |      *        parts.
38 |      * @return \ZBateson\MailMimeParser\Header\IHeaderPart[] Array of resulting
39 |      *         final parts.
40 |      */
41 |     protected function processParts(array $parts) : array
42 |     {
43 |         return [$this->partFactory->newDatePart($parts)];
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Header/GenericHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Consumer\GenericConsumerMimeLiteralPartService;
12 | use ZBateson\MailMimeParser\MailMimeParser;
13 | 
14 | /**
15 |  * Reads a generic header.
16 |  *
17 |  * Header's may contain mime-encoded parts, quoted parts, and comments.  The
18 |  * string value is the combined value of all its parts.
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | class GenericHeader extends AbstractHeader
23 | {
24 |     public function __construct(
25 |         string $name,
26 |         string $value,
27 |         ?LoggerInterface $logger = null,
28 |         ?GenericConsumerMimeLiteralPartService $consumerService = null
29 |     ) {
30 |         $di = MailMimeParser::getGlobalContainer();
31 |         parent::__construct(
32 |             $logger ?? $di->get(LoggerInterface::class),
33 |             $consumerService ?? $di->get(DateConsumerService::class),
34 |             $name,
35 |             $value
36 |         );
37 |         parent::__construct($logger, $consumerService, $name, $value);
38 |     }
39 | 
40 |     public function getValue() : ?string
41 |     {
42 |         if (!empty($this->parts)) {
43 |             return \implode('', \array_map(function($p) { return $p->getValue(); }, $this->parts));
44 |         }
45 |         return null;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/IdConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use ZBateson\MailMimeParser\Header\IHeaderPart;
11 | 
12 | /**
13 |  * Parses a single ID from an ID header.  Begins consuming on a '<' char, and
14 |  * ends on a '>' char.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | class IdConsumerService extends GenericConsumerService
19 | {
20 |     /**
21 |      * Overridden to return patterns matching the beginning part of an ID ('<'
22 |      * and '>' chars).
23 |      *
24 |      * @return string[] the patterns
25 |      */
26 |     public function getTokenSeparators() : array
27 |     {
28 |         return \array_merge(parent::getTokenSeparators(), ['<', '>']);
29 |     }
30 | 
31 |     /**
32 |      * Returns true for '>'.
33 |      */
34 |     protected function isEndToken(string $token) : bool
35 |     {
36 |         return ($token === '>');
37 |     }
38 | 
39 |     /**
40 |      * Returns true for '<'.
41 |      */
42 |     protected function isStartToken(string $token) : bool
43 |     {
44 |         return ($token === '<');
45 |     }
46 | 
47 |     /**
48 |      * Returns null for whitespace, and Token for anything else.
49 |      */
50 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
51 |     {
52 |         if (\preg_match('/^\s+$/', $token)) {
53 |             return null;
54 |         }
55 |         return $this->partFactory->newToken($token, true);
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "zbateson/mail-mime-parser",
 3 |     "description": "MIME email message parser",
 4 |     "keywords": ["mail", "mime", "parser", "email", "php-imap", "mailparse", "mimeparse", "MimeMailParser"],
 5 |     "homepage": "https://mail-mime-parser.org",
 6 |     "license": "BSD-2-Clause",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Zaahid Bateson"
10 |         },
11 |         {
12 |             "name": "Contributors",
13 |             "homepage": "https://github.com/zbateson/mail-mime-parser/graphs/contributors"
14 |         }
15 |     ],
16 |     "support": {
17 |         "issues": "https://github.com/zbateson/mail-mime-parser/issues",
18 |         "source": "https://github.com/zbateson/mail-mime-parser",
19 |         "docs": "https://mail-mime-parser.org/#usage-guide"
20 |     },
21 |     "require": {
22 |         "php": ">=8.0",
23 |         "guzzlehttp/psr7": "^2.5",
24 |         "zbateson/mb-wrapper": "^2.0",
25 |         "zbateson/stream-decorators": "^2.1",
26 |         "php-di/php-di": "^6.0|^7.0",
27 |         "psr/log": "^1|^2|^3"
28 |     },
29 |     "require-dev": {
30 |         "phpunit/phpunit": "^9.6",
31 |         "friendsofphp/php-cs-fixer": "*",
32 |         "phpstan/phpstan": "*",
33 |         "monolog/monolog": "^2|^3"
34 |     },
35 |     "suggest": {
36 |         "ext-mbstring": "For best support/performance",
37 |         "ext-iconv": "For best support/performance"
38 |     },
39 |     "autoload": {
40 |         "psr-4": {"ZBateson\\MailMimeParser\\": "src/"}
41 |     },
42 |     "autoload-dev": {
43 |         "psr-4": {"ZBateson\\MailMimeParser\\": "tests/MailMimeParser"}
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Message/IUUEncodedPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message;
 9 | 
10 | /**
11 |  * An interface representing a non-mime uuencoded part.
12 |  *
13 |  * Prior to the MIME standard, a plain text email may have included attachments
14 |  * below it surrounded by 'begin' and 'end' lines and uuencoded data between
15 |  * them.  Those attachments are captured as 'IUUEncodedPart' objects.
16 |  *
17 |  * The 'begin' line included a file name and unix file mode.  IUUEncodedPart
18 |  * allows reading/setting those parameters.
19 |  *
20 |  * IUUEncodedPart returns a Content-Transfer-Encoding of x-uuencode, a
21 |  * Content-Type of application-octet-stream, and a Content-Disposition of
22 |  * 'attachment'.  It also expects a mode and filename to initialize it, and
23 |  * adds 'filename' parts to the Content-Disposition and a 'name' parameter to
24 |  * Content-Type.
25 |  *
26 |  * @author Zaahid Bateson
27 |  */
28 | interface IUUEncodedPart extends IMessagePart
29 | {
30 |     /**
31 |      * Sets the filename included in the uuencoded 'begin' line.
32 |      */
33 |     public function setFilename(string $filename) : static;
34 | 
35 |     /**
36 |      * Returns the file mode included in the uuencoded 'begin' line for this
37 |      * part.
38 |      */
39 |     public function getUnixFileMode() : ?int;
40 | 
41 |     /**
42 |      * Sets the unix file mode for the uuencoded 'begin' line.
43 |      */
44 |     public function setUnixFileMode(int $mode) : static;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Header/Part/QuotedLiteralPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | /**
11 |  * A quoted literal header string part.  The value of the part is stripped of CR
12 |  * and LF characters, and whitespace between two adjacent MimeTokens is removed.
13 |  *
14 |  * @author Zaahid Bateson
15 |  */
16 | class QuotedLiteralPart extends ContainerPart
17 | {
18 |     /**
19 |      * Strips spaces found between two adjacent MimeToken parts.
20 |      * Other whitespace is returned as-is.
21 |      *
22 |      * @param HeaderPart[] $parts
23 |      * @return HeaderPart[]
24 |      */
25 |     protected function filterIgnoredSpaces(array $parts) : array
26 |     {
27 |         $filtered = \array_reduce(
28 |             \array_keys($parts),
29 |             function($carry, $key) use ($parts) {
30 |                 $cur = $parts[$key];
31 |                 $last = ($carry !== null) ? \end($carry) : null;
32 |                 $next = (count($parts) > $key + 1) ? $parts[$key + 1] : null;
33 |                 if ($last !== null && $next !== null && $cur->isSpace && (
34 |                     $last->canIgnoreSpacesAfter
35 |                     && $next->canIgnoreSpacesBefore
36 |                     && $last instanceof MimeToken
37 |                     && $next instanceof MimeToken
38 |                 )) {
39 |                     return $carry;
40 |                 }
41 |                 return \array_merge($carry ?? [], [$cur]);
42 |             }
43 |         );
44 |         return $filtered;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Message/Factory/PartStreamContainerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message\Factory;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Message\PartStreamContainer;
12 | use ZBateson\MailMimeParser\Stream\StreamFactory;
13 | use ZBateson\MbWrapper\MbWrapper;
14 | 
15 | /**
16 |  * Creates PartStreamContainer instances.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class PartStreamContainerFactory
21 | {
22 |     protected LoggerInterface $logger;
23 | 
24 |     protected StreamFactory $streamFactory;
25 | 
26 |     protected MbWrapper $mbWrapper;
27 | 
28 |     protected bool $throwExceptionReadingPartContentFromUnsupportedCharsets;
29 | 
30 |     public function __construct(
31 |         LoggerInterface $logger,
32 |         StreamFactory $streamFactory,
33 |         MbWrapper $mbWrapper,
34 |         bool $throwExceptionReadingPartContentFromUnsupportedCharsets
35 |     ) {
36 |         $this->logger = $logger;
37 |         $this->streamFactory = $streamFactory;
38 |         $this->mbWrapper = $mbWrapper;
39 |         $this->throwExceptionReadingPartContentFromUnsupportedCharsets = $throwExceptionReadingPartContentFromUnsupportedCharsets;
40 |     }
41 | 
42 |     public function newInstance() : PartStreamContainer
43 |     {
44 |         return new PartStreamContainer(
45 |             $this->logger,
46 |             $this->streamFactory,
47 |             $this->mbWrapper,
48 |             $this->throwExceptionReadingPartContentFromUnsupportedCharsets
49 |         );
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Parser/Part/ParserPartChildrenContainer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Part;
 9 | 
10 | use ZBateson\MailMimeParser\Message\PartChildrenContainer;
11 | use ZBateson\MailMimeParser\Parser\Proxy\ParserMimePartProxy;
12 | 
13 | /**
14 |  * A child container that proxies calls to a parser when attempting to access
15 |  * child parts.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class ParserPartChildrenContainer extends PartChildrenContainer
20 | {
21 |     /**
22 |      * @var ParserMimePartProxy The parser to proxy requests to when trying to
23 |      *      get child parts.
24 |      */
25 |     protected ParserMimePartProxy $parserProxy;
26 | 
27 |     /**
28 |      * @var bool Set to true once all parts have been parsed, and requests to
29 |      *      the proxy won't result in any more child parts.
30 |      */
31 |     private bool $allParsed = false;
32 | 
33 |     public function __construct(ParserMimePartProxy $parserProxy)
34 |     {
35 |         parent::__construct([]);
36 |         $this->parserProxy = $parserProxy;
37 |     }
38 | 
39 |     public function offsetExists($offset) : bool
40 |     {
41 |         $exists = parent::offsetExists($offset);
42 |         while (!$exists && !$this->allParsed) {
43 |             $child = $this->parserProxy->popNextChild();
44 |             if ($child === null) {
45 |                 $this->allParsed = true;
46 |             } else {
47 |                 $this->add($child);
48 |             }
49 |             $exists = parent::offsetExists($offset);
50 |         }
51 |         return $exists;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Message/NonMimePart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message;
 9 | 
10 | /**
11 |  * Represents part of a non-mime message.
12 |  *
13 |  * @author Zaahid Bateson
14 |  */
15 | abstract class NonMimePart extends MessagePart
16 | {
17 |     /**
18 |      * Returns true.
19 |      *
20 |      */
21 |     public function isTextPart() : bool
22 |     {
23 |         return true;
24 |     }
25 | 
26 |     /**
27 |      * Returns text/plain
28 |      */
29 |     public function getContentType(string $default = 'text/plain') : ?string
30 |     {
31 |         return $default;
32 |     }
33 | 
34 |     /**
35 |      * Returns ISO-8859-1
36 |      */
37 |     public function getCharset() : ?string
38 |     {
39 |         return 'ISO-8859-1';
40 |     }
41 | 
42 |     /**
43 |      * Returns 'inline'.
44 |      */
45 |     public function getContentDisposition(?string $default = 'inline') : ?string
46 |     {
47 |         return 'inline';
48 |     }
49 | 
50 |     /**
51 |      * Returns '7bit'.
52 |      */
53 |     public function getContentTransferEncoding(?string $default = '7bit') : ?string
54 |     {
55 |         return '7bit';
56 |     }
57 | 
58 |     /**
59 |      * Returns false.
60 |      *
61 |      */
62 |     public function isMime() : bool
63 |     {
64 |         return false;
65 |     }
66 | 
67 |     /**
68 |      * Returns the Content ID of the part.
69 |      *
70 |      * NonMimeParts do not have a Content ID, and so this simply returns null.
71 |      *
72 |      */
73 |     public function getContentId() : ?string
74 |     {
75 |         return null;
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Parser/Part/ParserPartStreamContainerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxy;
12 | use ZBateson\MailMimeParser\Stream\StreamFactory;
13 | use ZBateson\MbWrapper\MbWrapper;
14 | 
15 | /**
16 |  * Creates ParserPartStreamContainer instances.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class ParserPartStreamContainerFactory
21 | {
22 |     protected LoggerInterface $logger;
23 | 
24 |     protected StreamFactory $streamFactory;
25 | 
26 |     protected MbWrapper $mbWrapper;
27 | 
28 |     protected bool $throwExceptionReadingPartContentFromUnsupportedCharsets;
29 | 
30 |     public function __construct(
31 |         LoggerInterface $logger,
32 |         StreamFactory $streamFactory,
33 |         MbWrapper $mbWrapper,
34 |         bool $throwExceptionReadingPartContentFromUnsupportedCharsets
35 |     ) {
36 |         $this->logger = $logger;
37 |         $this->streamFactory = $streamFactory;
38 |         $this->mbWrapper = $mbWrapper;
39 |         $this->throwExceptionReadingPartContentFromUnsupportedCharsets = $throwExceptionReadingPartContentFromUnsupportedCharsets;
40 |     }
41 | 
42 |     public function newInstance(ParserPartProxy $parserProxy) : ParserPartStreamContainer
43 |     {
44 |         return new ParserPartStreamContainer(
45 |             $this->logger,
46 |             $this->streamFactory,
47 |             $this->mbWrapper,
48 |             $this->throwExceptionReadingPartContentFromUnsupportedCharsets,
49 |             $parserProxy
50 |         );
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Header/Part/AddressPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use Psr\Log\LogLevel;
11 | 
12 | /**
13 |  * Holds a single address or name/address pair.
14 |  *
15 |  * The name part of the address may be mime-encoded, but the email address part
16 |  * can't be mime-encoded.  Any whitespace in the email address part is stripped
17 |  * out.
18 |  *
19 |  * A convenience method, getEmail, is provided for clarity -- but getValue
20 |  * returns the email address as well.
21 |  *
22 |  * @author Zaahid Bateson
23 |  */
24 | class AddressPart extends NameValuePart
25 | {
26 |     protected function getValueFromParts(array $parts) : string
27 |     {
28 |         return \implode('', \array_map(
29 |             function($p) {
30 |                 if ($p instanceof AddressPart) {
31 |                     return $p->getValue();
32 |                 } elseif ($p instanceof QuotedLiteralPart && $p->getValue() !== '') {
33 |                     return '"' . \preg_replace('/(["\\\])/', '\\\$1', $p->getValue()) . '"';
34 |                 }
35 |                 return \preg_replace('/\s+/', '', $p->getValue());
36 |             },
37 |             $parts
38 |         ));
39 |     }
40 | 
41 |     /**
42 |      * Returns the email address.
43 |      *
44 |      * @return string The email address.
45 |      */
46 |     public function getEmail() : string
47 |     {
48 |         return $this->value;
49 |     }
50 | 
51 |     protected function validate() : void
52 |     {
53 |         if (empty($this->value)) {
54 |             $this->addError('Address doesn\'t contain an email address', LogLevel::ERROR);
55 |         }
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Parser/Part/UUEncodedPartHeaderContainer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Part;
 9 | 
10 | use ZBateson\MailMimeParser\Message\PartHeaderContainer;
11 | 
12 | /**
13 |  * Header container representing the start line of a uu-encoded part.
14 |  *
15 |  * The line may contain a unix file mode and a filename.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class UUEncodedPartHeaderContainer extends PartHeaderContainer
20 | {
21 |     /**
22 |      * @var ?int the unix file permission
23 |      */
24 |     protected ?int $mode = null;
25 | 
26 |     /**
27 |      * @var ?string the name of the file in the uuencoding 'header'.
28 |      */
29 |     protected ?string $filename = null;
30 | 
31 |     /**
32 |      * Returns the file mode included in the uuencoded 'begin' line for this
33 |      * part.
34 |      */
35 |     public function getUnixFileMode() : ?int
36 |     {
37 |         return $this->mode;
38 |     }
39 | 
40 |     /**
41 |      * Sets the unix file mode for the uuencoded 'begin' line.
42 |      */
43 |     public function setUnixFileMode(int $mode) : static
44 |     {
45 |         $this->mode = $mode;
46 |         return $this;
47 |     }
48 | 
49 |     /**
50 |      * Returns the filename included in the uuencoded 'begin' line for this
51 |      * part.
52 |      */
53 |     public function getFilename() : ?string
54 |     {
55 |         return $this->filename;
56 |     }
57 | 
58 |     /**
59 |      * Sets the filename included in the uuencoded 'begin' line.
60 |      */
61 |     public function setFilename(string $filename) : static
62 |     {
63 |         $this->filename = $filename;
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserNonMimeMessageProxyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Proxy;
 9 | 
10 | use ZBateson\MailMimeParser\Message;
11 | use ZBateson\MailMimeParser\Parser\IParserService;
12 | use ZBateson\MailMimeParser\Parser\PartBuilder;
13 | 
14 | /**
15 |  * Responsible for creating proxied IMessage instances wrapped in a
16 |  * ParserNonMimeMessageProxy for NonMimeParser.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class ParserNonMimeMessageProxyFactory extends ParserMessageProxyFactory
21 | {
22 |     /**
23 |      * Constructs a new ParserNonMimeMessageProxy wrapping an IMessage object.
24 |      */
25 |     public function newInstance(PartBuilder $partBuilder, IParserService $parser) : ParserNonMimeMessageProxy
26 |     {
27 |         $parserProxy = new ParserNonMimeMessageProxy($partBuilder, $parser);
28 | 
29 |         $streamContainer = $this->parserPartStreamContainerFactory->newInstance($parserProxy);
30 |         $headerContainer = $this->partHeaderContainerFactory->newInstance($parserProxy->getHeaderContainer());
31 |         $childrenContainer = $this->parserPartChildrenContainerFactory->newInstance($parserProxy);
32 | 
33 |         $message = new Message(
34 |             $this->logger,
35 |             $streamContainer,
36 |             $headerContainer,
37 |             $childrenContainer,
38 |             $this->multipartHelper,
39 |             $this->privacyHelper
40 |         );
41 |         $parserProxy->setPart($message);
42 | 
43 |         $streamContainer->setStream($this->streamFactory->newMessagePartStream($message));
44 |         $message->attach($streamContainer);
45 |         return $parserProxy;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Stream/MessagePartStreamDecorator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Stream;
 9 | 
10 | use GuzzleHttp\Psr7\StreamDecoratorTrait;
11 | use Psr\Http\Message\StreamInterface;
12 | use RuntimeException;
13 | use ZBateson\MailMimeParser\Message\IMessagePart;
14 | 
15 | /**
16 |  * Provides a readable stream for a MessagePart.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class MessagePartStreamDecorator implements StreamInterface
21 | {
22 |     use StreamDecoratorTrait {
23 |         read as private decoratorRead;
24 |     }
25 | 
26 |     /**
27 |      * @var IMessagePart The part to read from.
28 |      */
29 |     protected IMessagePart $part;
30 | 
31 |     protected ?StreamInterface $stream;
32 | 
33 |     public function __construct(IMessagePart $part, ?StreamInterface $stream = null)
34 |     {
35 |         $this->part = $part;
36 |         $this->stream = $stream;
37 |     }
38 | 
39 |     /**
40 |      * Overridden to wrap exceptions in MessagePartReadException which provides
41 |      * 'getPart' to inspect the part the error occurs on.
42 |      *
43 |      * @throws MessagePartStreamReadException
44 |      */
45 |     public function read(int $length) : string
46 |     {
47 |         try {
48 |             return $this->decoratorRead($length);
49 |         } catch (MessagePartStreamReadException $me) {
50 |             throw $me;
51 |         } catch (RuntimeException $e) {
52 |             throw new MessagePartStreamReadException(
53 |                 $this->part,
54 |                 'Exception occurred reading a part stream: cid=' . $this->part->getContentId()
55 |                 . ' type=' . $this->part->getContentType() . ', message: ' . $e->getMessage(),
56 |                 $e->getCode(),
57 |                 $e
58 |             );
59 |         }
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Header/Part/NameValuePart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use Psr\Log\LogLevel;
12 | use ZBateson\MailMimeParser\ErrorBag;
13 | use ZBateson\MbWrapper\MbWrapper;
14 | 
15 | /**
16 |  * Represents a name/value pair part of a header.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class NameValuePart extends ContainerPart
21 | {
22 |     /**
23 |      * @var string the name of the part
24 |      */
25 |     protected string $name;
26 | 
27 |     public function __construct(
28 |         LoggerInterface $logger,
29 |         MbWrapper $charsetConverter,
30 |         array $nameParts,
31 |         array $valueParts
32 |     ) {
33 |         ErrorBag::__construct($logger);
34 |         $this->charsetConverter = $charsetConverter;
35 |         $this->name = (!empty($nameParts)) ? $this->getNameFromParts($nameParts) : '';
36 |         parent::__construct($logger, $charsetConverter, $valueParts);
37 |         \array_unshift($this->children, ...$nameParts);
38 |     }
39 | 
40 |     /**
41 |      * Creates the string 'name' representation of this part constructed from
42 |      * the child name parts passed to it.
43 |      *
44 |      * @param HeaderParts[] $parts
45 |      */
46 |     protected function getNameFromParts(array $parts) : string
47 |     {
48 |         return \array_reduce($this->filterIgnoredSpaces($parts), fn ($c, $p) => $c . $p->getValue(), '');
49 |     }
50 | 
51 |     /**
52 |      * Returns the name of the name/value part.
53 |      */
54 |     public function getName() : string
55 |     {
56 |         return $this->name;
57 |     }
58 | 
59 |     protected function validate() : void
60 |     {
61 |         if ($this->value === '') {
62 |             $this->addError('NameValuePart value is empty', LogLevel::NOTICE);
63 |         }
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/ParameterValueConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Part\MimeTokenPartFactory;
12 | 
13 | /**
14 |  * Starts processing tokens after a '=' character is found, indicating the
15 |  * 'value' portion of a name/value pair in a parameter header.
16 |  *
17 |  * The value portion will consist of all tokens, quoted parts, and comment parts
18 |  * parsed up to a semi-colon token indicating control should be returned to the
19 |  * parent ParameterNameValueConsumerService.
20 |  *
21 |  * @author Zaahid Bateson
22 |  */
23 | class ParameterValueConsumerService extends GenericConsumerMimeLiteralPartService
24 | {
25 |     public function __construct(
26 |         LoggerInterface $logger,
27 |         MimeTokenPartFactory $partFactory,
28 |         CommentConsumerService $commentConsumerService,
29 |         QuotedStringMimeLiteralPartConsumerService $quotedStringConsumerService
30 |     ) {
31 |         parent::__construct(
32 |             $logger,
33 |             $partFactory,
34 |             $commentConsumerService,
35 |             $quotedStringConsumerService
36 |         );
37 |     }
38 | 
39 |     /**
40 |      * Returns semi-colon and equals char as token separators.
41 |      *
42 |      * @return string[]
43 |      */
44 |     protected function getTokenSeparators() : array
45 |     {
46 |         return \array_merge(parent::getTokenSeparators(), ['=', ';']);
47 |     }
48 | 
49 |     /**
50 |      * Returns true if the token is an '=' character.
51 |      */
52 |     protected function isStartToken(string $token) : bool
53 |     {
54 |         return ($token === '=');
55 |     }
56 | 
57 |     /**
58 |      * Returns true if the token is a ';' character.
59 |      */
60 |     protected function isEndToken(string $token) : bool
61 |     {
62 |         return ($token === ';');
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/Message/Factory/IMimePartFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Message\Factory;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Message\IMimePart;
12 | use ZBateson\MailMimeParser\Message\MimePart;
13 | use ZBateson\MailMimeParser\Stream\StreamFactory;
14 | 
15 | /**
16 |  * Responsible for creating IMimePart instances.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class IMimePartFactory extends IMessagePartFactory
21 | {
22 |     protected PartHeaderContainerFactory $partHeaderContainerFactory;
23 | 
24 |     protected PartChildrenContainerFactory $partChildrenContainerFactory;
25 | 
26 |     public function __construct(
27 |         LoggerInterface $logger,
28 |         StreamFactory $streamFactory,
29 |         PartStreamContainerFactory $partStreamContainerFactory,
30 |         PartHeaderContainerFactory $partHeaderContainerFactory,
31 |         PartChildrenContainerFactory $partChildrenContainerFactory
32 |     ) {
33 |         parent::__construct($logger, $streamFactory, $partStreamContainerFactory);
34 |         $this->partHeaderContainerFactory = $partHeaderContainerFactory;
35 |         $this->partChildrenContainerFactory = $partChildrenContainerFactory;
36 |     }
37 | 
38 |     /**
39 |      * Constructs a new IMimePart object and returns it
40 |      */
41 |     public function newInstance(?IMimePart $parent = null) : IMimePart
42 |     {
43 |         $streamContainer = $this->partStreamContainerFactory->newInstance();
44 |         $headerContainer = $this->partHeaderContainerFactory->newInstance();
45 |         $part = new MimePart(
46 |             $parent,
47 |             $this->logger,
48 |             $streamContainer,
49 |             $headerContainer,
50 |             $this->partChildrenContainerFactory->newInstance()
51 |         );
52 |         $streamContainer->setStream($this->streamFactory->newMessagePartStream($part));
53 |         return $part;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Header/DateHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | use DateTime;
11 | use DateTimeImmutable;
12 | use Psr\Log\LoggerInterface;
13 | use ZBateson\MailMimeParser\Header\Consumer\DateConsumerService;
14 | use ZBateson\MailMimeParser\Header\Part\DatePart;
15 | use ZBateson\MailMimeParser\MailMimeParser;
16 | 
17 | /**
18 |  * Reads a DatePart value header in either RFC 2822 or RFC 822 format.
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | class DateHeader extends AbstractHeader
23 | {
24 |     public function __construct(
25 |         string $name,
26 |         string $value,
27 |         ?LoggerInterface $logger = null,
28 |         ?DateConsumerService $consumerService = null
29 |     ) {
30 |         $di = MailMimeParser::getGlobalContainer();
31 |         parent::__construct(
32 |             $logger ?? $di->get(LoggerInterface::class),
33 |             $consumerService ?? $di->get(DateConsumerService::class),
34 |             $name,
35 |             $value
36 |         );
37 |     }
38 | 
39 |     /**
40 |      * Convenience method returning the part's DateTime object, or null if the
41 |      * date could not be parsed.
42 |      *
43 |      * @return ?DateTime The parsed DateTime object.
44 |      */
45 |     public function getDateTime() : ?DateTime
46 |     {
47 |         if (!empty($this->parts) && $this->parts[0] instanceof DatePart) {
48 |             return $this->parts[0]->getDateTime();
49 |         }
50 |         return null;
51 |     }
52 | 
53 |     /**
54 |      * Returns a DateTimeImmutable for the part's DateTime object, or null if
55 |      * the date could not be parsed.
56 |      *
57 |      * @return ?DateTimeImmutable The parsed DateTimeImmutable object.
58 |      */
59 |     public function getDateTimeImmutable() : ?DateTimeImmutable
60 |     {
61 |         $dateTime = $this->getDateTime();
62 |         if ($dateTime !== null) {
63 |             return DateTimeImmutable::createFromMutable($dateTime);
64 |         }
65 |         return null;
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Header/Part/Token.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MbWrapper\MbWrapper;
12 | 
13 | /**
14 |  * Holds a string value token that will require additional processing by a
15 |  * consumer prior to returning to a client.
16 |  *
17 |  * A Token is meant to hold a value for further processing -- for instance when
18 |  * consuming an address list header (like From or To) -- before it's known what
19 |  * type of IHeaderPart it is (could be an email address, could be a name, or
20 |  * could be a group.)
21 |  *
22 |  * @author Zaahid Bateson
23 |  */
24 | class Token extends HeaderPart
25 | {
26 |     /**
27 |      * @var string the raw value of the part.
28 |      */
29 |     protected string $rawValue;
30 | 
31 |     public function __construct(
32 |         LoggerInterface $logger,
33 |         MbWrapper $charsetConverter,
34 |         string $value,
35 |         bool $isLiteral = false,
36 |         bool $preserveSpaces = false
37 |     ) {
38 |         parent::__construct($logger, $charsetConverter, $value);
39 |         $this->rawValue = $value;
40 |         if (!$isLiteral) {
41 |             $this->value = \preg_replace(['/(\r|\n)+(\s)/', '/(\r|\n)+/'], ['$2', ' '], $value);
42 |             if (!$preserveSpaces) {
43 |                 $this->value = \preg_replace('/^\s+$/m', ' ', $this->value);
44 |             }
45 |         }
46 |         $this->isSpace = ($this->value === '' || (!$isLiteral && \preg_match('/^\s*$/m', $this->value) === 1));
47 |         $this->canIgnoreSpacesBefore = $this->canIgnoreSpacesAfter = $this->isSpace;
48 |     }
49 | 
50 |     /**
51 |      * Returns the part's representative value after any necessary processing
52 |      * has been performed.  For the raw value, call getRawValue().
53 |      */
54 |     public function getValue() : string
55 |     {
56 |         return $this->convertEncoding($this->value);
57 |     }
58 | 
59 |     /**
60 |      * Returns the part's raw value.
61 |      */
62 |     public function getRawValue() : string
63 |     {
64 |         return $this->rawValue;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserUUEncodedPartProxyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Proxy;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Message\UUEncodedPart;
12 | use ZBateson\MailMimeParser\Parser\IParserService;
13 | use ZBateson\MailMimeParser\Parser\Part\ParserPartStreamContainerFactory;
14 | use ZBateson\MailMimeParser\Parser\PartBuilder;
15 | use ZBateson\MailMimeParser\Stream\StreamFactory;
16 | 
17 | /**
18 |  * Responsible for creating proxied IUUEncodedPart instances wrapped in a
19 |  * ParserUUEncodedPartProxy and used by NonMimeParser.
20 |  *
21 |  * @author Zaahid Bateson
22 |  */
23 | class ParserUUEncodedPartProxyFactory extends ParserPartProxyFactory
24 | {
25 |     protected LoggerInterface $logger;
26 | 
27 |     protected StreamFactory $streamFactory;
28 | 
29 |     protected ParserPartStreamContainerFactory $parserPartStreamContainerFactory;
30 | 
31 |     public function __construct(
32 |         LoggerInterface $logger,
33 |         StreamFactory $sdf,
34 |         ParserPartStreamContainerFactory $parserPartStreamContainerFactory
35 |     ) {
36 |         $this->logger = $logger;
37 |         $this->streamFactory = $sdf;
38 |         $this->parserPartStreamContainerFactory = $parserPartStreamContainerFactory;
39 |     }
40 | 
41 |     /**
42 |      * Constructs a new ParserUUEncodedPartProxy wrapping an IUUEncoded object.
43 |      */
44 |     public function newInstance(PartBuilder $partBuilder, IParserService $parser) : ParserUUEncodedPartProxy
45 |     {
46 |         $parserProxy = new ParserUUEncodedPartProxy($partBuilder, $parser);
47 |         $streamContainer = $this->parserPartStreamContainerFactory->newInstance($parserProxy);
48 | 
49 |         $part = new UUEncodedPart(
50 |             $parserProxy->getUnixFileMode(),
51 |             $parserProxy->getFileName(),
52 |             $partBuilder->getParent()->getPart(),
53 |             $this->logger,
54 |             $streamContainer
55 |         );
56 |         $parserProxy->setPart($part);
57 | 
58 |         $streamContainer->setStream($this->streamFactory->newMessagePartStream($part));
59 |         $part->attach($streamContainer);
60 |         return $parserProxy;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Header/IdHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Consumer\IdBaseConsumerService;
12 | use ZBateson\MailMimeParser\Header\Part\CommentPart;
13 | use ZBateson\MailMimeParser\Header\Part\MimeTokenPartFactory;
14 | use ZBateson\MailMimeParser\MailMimeParser;
15 | 
16 | /**
17 |  * Represents a Content-ID, Message-ID, In-Reply-To or References header.
18 |  *
19 |  * For a multi-id header like In-Reply-To or References, all IDs can be
20 |  * retrieved by calling {@see IdHeader::getIds()}.  Otherwise, to retrieve the
21 |  * first (or only) ID call {@see IdHeader::getValue()}.
22 |  *
23 |  * @author Zaahid Bateson
24 |  */
25 | class IdHeader extends MimeEncodedHeader
26 | {
27 |     public function __construct(
28 |         string $name,
29 |         string $value,
30 |         ?LoggerInterface $logger = null,
31 |         ?MimeTokenPartFactory $mimeTokenPartFactory = null,
32 |         ?IdBaseConsumerService $consumerService = null
33 |     ) {
34 |         $di = MailMimeParser::getGlobalContainer();
35 |         parent::__construct(
36 |             $logger ?? $di->get(LoggerInterface::class),
37 |             $mimeTokenPartFactory ?? $di->get(MimeTokenPartFactory::class),
38 |             $consumerService ?? $di->get(IdBaseConsumerService::class),
39 |             $name,
40 |             $value
41 |         );
42 |     }
43 | 
44 |     /**
45 |      * Returns the ID. Synonymous to calling getValue().
46 |      *
47 |      * @return string|null The ID
48 |      */
49 |     public function getId() : ?string
50 |     {
51 |         return $this->getValue();
52 |     }
53 | 
54 |     /**
55 |      * Returns all IDs parsed for a multi-id header like References or
56 |      * In-Reply-To.
57 |      *
58 |      * @return string[] An array of IDs
59 |      */
60 |     public function getIds() : array
61 |     {
62 |         return \array_values(\array_map(
63 |             function($p) {
64 |                 return $p->getValue();
65 |             },
66 |             \array_filter($this->parts, function($p) {
67 |                 return !($p instanceof CommentPart);
68 |             })
69 |         ));
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/AbstractGenericConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | /**
11 |  * A minimal implementation of AbstractConsumerService splitting tokens by
12 |  * whitespace.
13 |  *
14 |  * Although the class doesn't have any abstract methods, it's defined as
15 |  * abstract because it doesn't define specific sub-consumers as constructor
16 |  * dependencies, and so is defined as abstract to avoid its direct use (use
17 |  * the concrete GenericConsumerService or GenericConsumerMimeLiteralPartService
18 |  * classes instead).
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | abstract class AbstractGenericConsumerService extends AbstractConsumerService
23 | {
24 |     /**
25 |      * Returns the regex '\s+' (whitespace) pattern matcher as a token marker so
26 |      * the header value is split along whitespace characters.
27 |      *
28 |      * @return string[] an array of regex pattern matchers
29 |      */
30 |     protected function getTokenSeparators() : array
31 |     {
32 |         return ['\s+'];
33 |     }
34 | 
35 |     /**
36 |      * AbstractGenericConsumerService doesn't have start/end tokens, and so
37 |      * always returns false.
38 |      */
39 |     protected function isEndToken(string $token) : bool
40 |     {
41 |         return false;
42 |     }
43 | 
44 |     /**
45 |      * AbstractGenericConsumerService doesn't have start/end tokens, and so
46 |      * always returns false.
47 |      *
48 |      * @codeCoverageIgnore
49 |      */
50 |     protected function isStartToken(string $token) : bool
51 |     {
52 |         return false;
53 |     }
54 | 
55 |     /**
56 |      * Overridden to combine all part values into a single string and return it
57 |      * as an array with a single element.
58 |      *
59 |      * The returned IHeaderPart array consists of a single ContainerPart created
60 |      * out of all passed IHeaderParts.
61 |      *
62 |      * @param \ZBateson\MailMimeParser\Header\IHeaderPart[] $parts
63 |      * @return \ZBateson\MailMimeParser\Header\IHeaderPart[]
64 |      */
65 |     protected function processParts(array $parts) : array
66 |     {
67 |         return [$this->partFactory->newContainerPart($parts)];
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/SubjectConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Iterator;
11 | use Psr\Log\LoggerInterface;
12 | use ZBateson\MailMimeParser\Header\IHeaderPart;
13 | use ZBateson\MailMimeParser\Header\Part\MimeToken;
14 | use ZBateson\MailMimeParser\Header\Part\MimeTokenPartFactory;
15 | 
16 | /**
17 |  * Extends AbstractGenericConsumerService to use a MimeTokenPartFactory, and
18 |  * to preserve all whitespace and escape sequences as-is (unlike other headers
19 |  * subject headers don't have escape chars such as '\\' for a backslash).
20 |  *
21 |  * SubjectConsumerService doesn't define any sub-consumers.
22 |  *
23 |  * @author Zaahid Bateson
24 |  */
25 | class SubjectConsumerService extends AbstractGenericConsumerService
26 | {
27 |     public function __construct(LoggerInterface $logger, MimeTokenPartFactory $partFactory)
28 |     {
29 |         parent::__construct($logger, $partFactory);
30 |     }
31 | 
32 |     /**
33 |      * Overridden to preserve whitespace.
34 |      *
35 |      * Whitespace between two words is preserved unless the whitespace begins
36 |      * with a newline (\n or \r\n), in which case the entire string of
37 |      * whitespace is discarded, and a single space ' ' character is used in its
38 |      * place.
39 |      */
40 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
41 |     {
42 |         if (\preg_match('/' . MimeToken::MIME_PART_PATTERN . '/', $token)) {
43 |             return $this->partFactory->newMimeToken($token);
44 |         }
45 |         return $this->partFactory->newSubjectToken($token);
46 |     }
47 | 
48 |     /**
49 |      * Returns an array of \ZBateson\MailMimeParser\Header\Part\HeaderPart for
50 |      * the current token on the iterator.
51 |      *
52 |      * Overridden from AbstractConsumerService to remove special filtering for
53 |      * backslash escaping, which also seems to not apply to Subject headers at
54 |      * least in ThunderBird's implementation.
55 |      *
56 |      * @return IHeaderPart[]
57 |      */
58 |     protected function getTokenParts(Iterator $tokens) : array
59 |     {
60 |         return $this->getConsumerTokenParts($tokens);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Header/Part/CommentPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MbWrapper\MbWrapper;
12 | 
13 | /**
14 |  * Represents a mime header comment -- text in a structured mime header
15 |  * value existing within parentheses.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class CommentPart extends ContainerPart
20 | {
21 |     /**
22 |      * @var HeaderPartFactory used to create intermediate parts.
23 |      */
24 |     protected HeaderPartFactory $partFactory;
25 | 
26 |     /**
27 |      * @var string the contents of the comment
28 |      */
29 |     protected string $comment;
30 | 
31 |     public function __construct(
32 |         LoggerInterface $logger,
33 |         MbWrapper $charsetConverter,
34 |         HeaderPartFactory $partFactory,
35 |         array $children
36 |     ) {
37 |         $this->partFactory = $partFactory;
38 |         parent::__construct($logger, $charsetConverter, $children);
39 |         $this->comment = $this->value;
40 |         $this->value = '';
41 |         $this->isSpace = true;
42 |         $this->canIgnoreSpacesBefore = true;
43 |         $this->canIgnoreSpacesAfter = true;
44 |     }
45 | 
46 |     protected function getValueFromParts(array $parts) : string
47 |     {
48 |         $partFactory = $this->partFactory;
49 |         return parent::getValueFromParts(\array_map(
50 |             function($p) use ($partFactory) {
51 |                 if ($p instanceof CommentPart) {
52 |                     return $partFactory->newQuotedLiteralPart([$partFactory->newToken('(' . $p->getComment() . ')')]);
53 |                 } elseif ($p instanceof QuotedLiteralPart) {
54 |                     return $partFactory->newQuotedLiteralPart([$partFactory->newToken('"' . \str_replace('(["\\])', '\$1', $p->getValue()) . '"')]);
55 |                 }
56 |                 return $p;
57 |             },
58 |             $parts
59 |         ));
60 |     }
61 | 
62 |     /**
63 |      * Returns the comment's text.
64 |      */
65 |     public function getComment() : string
66 |     {
67 |         return $this->comment;
68 |     }
69 | 
70 |     /**
71 |      * Returns an empty string.
72 |      */
73 |     public function getValue() : string
74 |     {
75 |         return '';
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Parser/HeaderParserService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser;
 9 | 
10 | use Psr\Log\LogLevel;
11 | use ZBateson\MailMimeParser\Message\PartHeaderContainer;
12 | 
13 | /**
14 |  * Reads headers from an input stream, adding them to a PartHeaderContainer.
15 |  *
16 |  * @author Zaahid Bateson
17 |  */
18 | class HeaderParserService
19 | {
20 |     /**
21 |      * Ensures the header isn't empty and contains a colon separator character,
22 |      * then splits it and adds it to the passed PartHeaderContainer.
23 |      *
24 |      * @param int $offset read offset for error reporting
25 |      * @param string $header the header line
26 |      * @param PartHeaderContainer $headerContainer the container
27 |      */
28 |     private function addRawHeaderToPart(int $offset, string $header, PartHeaderContainer $headerContainer) : static
29 |     {
30 |         if ($header !== '') {
31 |             if (\strpos($header, ':') !== false) {
32 |                 $a = \explode(':', $header, 2);
33 |                 $headerContainer->add($a[0], \trim($a[1]));
34 |             } else {
35 |                 $headerContainer->addError(
36 |                     "Invalid header found at offset: $offset",
37 |                     LogLevel::ERROR
38 |                 );
39 |             }
40 |         }
41 |         return $this;
42 |     }
43 | 
44 |     /**
45 |      * Reads header lines up to an empty line, adding them to the passed
46 |      * PartHeaderContainer.
47 |      *
48 |      * @param resource $handle The resource handle to read from.
49 |      * @param PartHeaderContainer $container the container to add headers to.
50 |      */
51 |     public function parse($handle, PartHeaderContainer $container) : static
52 |     {
53 |         $header = '';
54 |         do {
55 |             $offset = \ftell($handle);
56 |             $line = MessageParserService::readLine($handle);
57 |             if ($line === false || $line === '' || $line[0] !== "\t" && $line[0] !== ' ') {
58 |                 $this->addRawHeaderToPart($offset, $header, $container);
59 |                 $header = '';
60 |             } else {
61 |                 $line = "\r\n" . $line;
62 |             }
63 |             $header .= \rtrim($line, "\r\n");
64 |         } while ($header !== '');
65 |         return $this;
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/QuotedStringConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use ZBateson\MailMimeParser\Header\IHeaderPart;
11 | 
12 | /**
13 |  * Represents a quoted part of a header value starting at a double quote, and
14 |  * ending at the next double quote.
15 |  *
16 |  * A quoted-pair part in a header is a literal.  There are no sub-consumers for
17 |  * it and a Part\LiteralPart is returned.
18 |  *
19 |  * Newline characters (CR and LF) are stripped entirely from the quoted part.
20 |  * This is based on the example at:
21 |  *
22 |  * https://tools.ietf.org/html/rfc822#section-3.1.1
23 |  *
24 |  * And https://www.w3.org/Protocols/rfc1341/7_2_Multipart.html in section 7.2.1
25 |  * splitting the boundary.
26 |  *
27 |  * @author Zaahid Bateson
28 |  */
29 | class QuotedStringConsumerService extends AbstractConsumerService
30 | {
31 |     /**
32 |      * Returns true if the token is a double quote.
33 |      */
34 |     protected function isStartToken(string $token) : bool
35 |     {
36 |         return ($token === '"');
37 |     }
38 | 
39 |     /**
40 |      * Returns true if the token is a double quote.
41 |      */
42 |     protected function isEndToken(string $token) : bool
43 |     {
44 |         return ($token === '"');
45 |     }
46 | 
47 |     /**
48 |      * Returns a single regex pattern for a double quote.
49 |      *
50 |      * @return string[]
51 |      */
52 |     protected function getTokenSeparators() : array
53 |     {
54 |         return ['\"'];
55 |     }
56 | 
57 |     /**
58 |      * Constructs a LiteralPart and returns it.
59 |      */
60 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
61 |     {
62 |         return $this->partFactory->newToken($token, $isLiteral, true);
63 |     }
64 | 
65 |     /**
66 |      * Overridden to combine all part values into a single string and return it
67 |      * as an array with a single element.
68 |      *
69 |      * The returned IHeaderParts is an array containing a single
70 |      * QuotedLiteralPart.
71 |      *
72 |      * @param IHeaderPart[] $parts
73 |      * @return IHeaderPart[]
74 |      */
75 |     protected function processParts(array $parts) : array
76 |     {
77 |         return [$this->partFactory->newQuotedLiteralPart($parts)];
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/Header/MimeEncodedHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Consumer\IConsumerService;
12 | use ZBateson\MailMimeParser\Header\Part\MimeToken;
13 | use ZBateson\MailMimeParser\Header\Part\MimeTokenPartFactory;
14 | 
15 | /**
16 |  * Allows a header to be mime-encoded and be decoded with a consumer after
17 |  * decoding.
18 |  *
19 |  * @author Zaahid Bateson
20 |  */
21 | abstract class MimeEncodedHeader extends AbstractHeader
22 | {
23 |     /**
24 |      * @var MimeTokenPartFactory for mime decoding.
25 |      */
26 |     protected MimeTokenPartFactory $mimeTokenPartFactory;
27 | 
28 |     /**
29 |      * @var MimeLiteralPart[] the mime encoded parsed parts contained in this
30 |      *      header
31 |      */
32 |     protected $mimeEncodedParsedParts = [];
33 | 
34 |     public function __construct(
35 |         LoggerInterface $logger,
36 |         MimeTokenPartFactory $mimeTokenPartFactory,
37 |         IConsumerService $consumerService,
38 |         string $name,
39 |         string $value
40 |     ) {
41 |         $this->mimeTokenPartFactory = $mimeTokenPartFactory;
42 |         parent::__construct($logger, $consumerService, $name, $value);
43 |     }
44 | 
45 |     /**
46 |      * Mime-decodes any mime-encoded parts prior to invoking
47 |      * parent::parseHeaderValue.
48 |      */
49 |     protected function parseHeaderValue(IConsumerService $consumer, string $value) : void
50 |     {
51 |         // handled differently from MimeLiteralPart's decoding which ignores
52 |         // whitespace between parts, etc...
53 |         $matchp = '~(' . MimeToken::MIME_PART_PATTERN . ')~';
54 |         $aMimeParts = \preg_split($matchp, $value, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
55 |         $this->mimeEncodedParsedParts = \array_map([$this->mimeTokenPartFactory, 'newInstance'], $aMimeParts);
56 |         parent::parseHeaderValue(
57 |             $consumer,
58 |             \implode('', \array_map(fn ($part) => $part->getValue(), $this->mimeEncodedParsedParts))
59 |         );
60 |     }
61 | 
62 |     protected function getErrorBagChildren() : array
63 |     {
64 |         return \array_values(\array_filter(\array_merge($this->getAllParts(), $this->mimeEncodedParsedParts)));
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Header/Part/DatePart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use DateTime;
11 | use Exception;
12 | use Psr\Log\LoggerInterface;
13 | use Psr\Log\LogLevel;
14 | use ZBateson\MbWrapper\MbWrapper;
15 | 
16 | /**
17 |  * Represents the value of a date header, parsing the date into a \DateTime
18 |  * object.
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | class DatePart extends ContainerPart
23 | {
24 |     /**
25 |      * @var DateTime the parsed date, or null if the date could not be parsed
26 |      */
27 |     protected ?DateTime $date = null;
28 | 
29 |     /**
30 |      * Tries parsing the passed token as an RFC 2822 date, and failing that into
31 |      * an RFC 822 date, and failing that, tries to parse it by calling
32 |      * new DateTime($value).
33 |      *
34 |      * @param HeaderPart[] $children
35 |      */
36 |     public function __construct(
37 |         LoggerInterface $logger,
38 |         MbWrapper $charsetConverter,
39 |         array $children
40 |     ) {
41 |         // parent::__construct converts character encoding -- may cause problems sometimes.
42 |         parent::__construct($logger, $charsetConverter, $children);
43 |         $this->value = $dateToken = \trim($this->value);
44 | 
45 |         // Missing "+" in timezone definition. eg: Thu, 13 Mar 2014 15:02:47 0000 (not RFC compliant)
46 |         // Won't result in an Exception, but in a valid DateTime in year `0000` - therefore we need to check this first:
47 |         if (\preg_match('# [0-9]{4}$#', $dateToken)) {
48 |             $dateToken = \preg_replace('# ([0-9]{4})$#', ' +$1', $dateToken);
49 |         // @see https://bugs.php.net/bug.php?id=42486
50 |         } elseif (\preg_match('#UT$#', $dateToken)) {
51 |             $dateToken = $dateToken . 'C';
52 |         }
53 | 
54 |         try {
55 |             $this->date = new DateTime($dateToken);
56 |         } catch (Exception $e) {
57 |             $this->addError(
58 |                 "Unable to parse date from header: \"{$dateToken}\"",
59 |                 LogLevel::ERROR,
60 |                 $e
61 |             );
62 |         }
63 |     }
64 | 
65 |     /**
66 |      * Returns a DateTime object or null if it can't be parsed.
67 |      */
68 |     public function getDateTime() : ?DateTime
69 |     {
70 |         return $this->date;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/AddressEmailConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
12 | 
13 | /**
14 |  * Parses the Address portion of an email address header, for an address part
15 |  * that contains both a name and an email address, e.g. "name" <email@tld.com>.
16 |  *
17 |  * The address portion found within the '<' and '>' chars may contain comments
18 |  * and quoted portions.
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | class AddressEmailConsumerService extends AbstractConsumerService
23 | {
24 |     public function __construct(
25 |         LoggerInterface $logger,
26 |         HeaderPartFactory $partFactory,
27 |         CommentConsumerService $commentConsumerService,
28 |         QuotedStringConsumerService $quotedStringConsumerService
29 |     ) {
30 |         parent::__construct(
31 |             $logger,
32 |             $partFactory,
33 |             [$commentConsumerService, $quotedStringConsumerService]
34 |         );
35 |     }
36 | 
37 |     /**
38 |      * Overridden to return patterns matching the beginning/end part of an
39 |      * address in a name/address part ("<" and ">" chars).
40 |      *
41 |      * @return string[] the patterns
42 |      */
43 |     public function getTokenSeparators() : array
44 |     {
45 |         return ['<', '>'];
46 |     }
47 | 
48 |     /**
49 |      * Returns true for the '>' char.
50 |      */
51 |     protected function isEndToken(string $token) : bool
52 |     {
53 |         return ($token === '>');
54 |     }
55 | 
56 |     /**
57 |      * Returns true for the '<' char.
58 |      */
59 |     protected function isStartToken(string $token) : bool
60 |     {
61 |         return ($token === '<');
62 |     }
63 | 
64 |     /**
65 |      * Returns a single {@see ZBateson\MailMimeParser\Header\Part\AddressPart}
66 |      * with its 'email' portion set, so an {@see AddressConsumerService} can
67 |      * identify it and create an
68 |      * {@see ZBateson\MailMimeParser\Header\Part\AddressPart} Address with
69 |      * both a name and email set.
70 |      *
71 |      * @param \ZBateson\MailMimeParser\Header\IHeaderPart[] $parts
72 |      * @return \ZBateson\MailMimeParser\Header\IHeaderPart[]|array
73 |      */
74 |     protected function processParts(array $parts) : array
75 |     {
76 |         return [$this->partFactory->newAddress([], $parts)];
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/Header/Part/AddressGroupPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Part;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use Psr\Log\LogLevel;
12 | use ZBateson\MbWrapper\MbWrapper;
13 | 
14 | /**
15 |  * Holds a group of addresses and a group name.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | class AddressGroupPart extends NameValuePart
20 | {
21 |     /**
22 |      * @var AddressPart[] an array of AddressParts
23 |      */
24 |     protected array $addresses;
25 | 
26 |     /**
27 |      * Creates an AddressGroupPart out of the passed array of AddressParts/
28 |      * AddressGroupParts and name.
29 |      *
30 |      * @param HeaderPart[] $nameParts
31 |      * @param AddressPart[]|AddressGroupPart[] $addressesAndGroupParts
32 |      */
33 |     public function __construct(
34 |         LoggerInterface $logger,
35 |         MbWrapper $charsetConverter,
36 |         array $nameParts,
37 |         array $addressesAndGroupParts
38 |     ) {
39 |         parent::__construct(
40 |             $logger,
41 |             $charsetConverter,
42 |             $nameParts,
43 |             $addressesAndGroupParts
44 |         );
45 |         $this->addresses = \array_merge(...\array_map(
46 |             fn ($p) => ($p instanceof AddressGroupPart) ? $p->getAddresses() : [$p],
47 |             $addressesAndGroupParts
48 |         ));
49 |         // for backwards compatibility
50 |         $this->value = $this->name;
51 |     }
52 | 
53 |     /**
54 |      * Return the AddressGroupPart's array of addresses.
55 |      *
56 |      * @return AddressPart[] An array of address parts.
57 |      */
58 |     public function getAddresses() : array
59 |     {
60 |         return $this->addresses;
61 |     }
62 | 
63 |     /**
64 |      * Returns the AddressPart at the passed index or null.
65 |      *
66 |      * @param int $index The 0-based index.
67 |      * @return ?AddressPart The address.
68 |      */
69 |     public function getAddress(int $index) : ?AddressPart
70 |     {
71 |         if (!isset($this->addresses[$index])) {
72 |             return null;
73 |         }
74 |         return $this->addresses[$index];
75 |     }
76 | 
77 |     protected function validate() : void
78 |     {
79 |         if ($this->name === null || \mb_strlen($this->name) === 0) {
80 |             $this->addError('Address group doesn\'t have a name', LogLevel::ERROR);
81 |         }
82 |         if (empty($this->addresses)) {
83 |             $this->addError('Address group doesn\'t have any email addresses defined in it', LogLevel::NOTICE);
84 |         }
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/src/Parser/AbstractParserService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser;
 9 | 
10 | use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxyFactory;
11 | 
12 | /**
13 |  * Provides basic implementations for:
14 |  * - IParser::setParserManager
15 |  * - IParser::getParserMessageProxyFactory (returns $this->parserMessageProxyFactory
16 |  *   which can be set via the default constructor)
17 |  * - IParser::getParserPartProxyFactory (returns $this->parserPartProxyFactory
18 |  *   which can be set via the default constructor)
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | abstract class AbstractParserService implements IParserService
23 | {
24 |     /**
25 |      * @var ParserPartProxyFactory the parser's message proxy factory service
26 |      *      responsible for creating an IMessage part wrapped in a
27 |      *      ParserPartProxy.
28 |      */
29 |     protected ParserPartProxyFactory $parserMessageProxyFactory;
30 | 
31 |     /**
32 |      * @var ParserPartProxyFactory the parser's part proxy factory service
33 |      *      responsible for creating IMessagePart parts wrapped in a
34 |      *      ParserPartProxy.
35 |      */
36 |     protected ParserPartProxyFactory $parserPartProxyFactory;
37 | 
38 |     /**
39 |      * @var PartBuilderFactory Service for creating PartBuilder objects for new
40 |      *      children.
41 |      */
42 |     protected PartBuilderFactory $partBuilderFactory;
43 | 
44 |     /**
45 |      * @var ParserManagerService the ParserManager, which should call setParserManager
46 |      *      when the parser is added.
47 |      */
48 |     protected ParserManagerService $parserManager;
49 | 
50 |     public function __construct(
51 |         ParserPartProxyFactory $parserMessageProxyFactory,
52 |         ParserPartProxyFactory $parserPartProxyFactory,
53 |         PartBuilderFactory $partBuilderFactory
54 |     ) {
55 |         $this->parserMessageProxyFactory = $parserMessageProxyFactory;
56 |         $this->parserPartProxyFactory = $parserPartProxyFactory;
57 |         $this->partBuilderFactory = $partBuilderFactory;
58 |     }
59 | 
60 |     public function setParserManager(ParserManagerService $pm) : static
61 |     {
62 |         $this->parserManager = $pm;
63 |         return $this;
64 |     }
65 | 
66 |     public function getParserMessageProxyFactory() : ParserPartProxyFactory
67 |     {
68 |         return $this->parserMessageProxyFactory;
69 |     }
70 | 
71 |     public function getParserPartProxyFactory() : ParserPartProxyFactory
72 |     {
73 |         return $this->parserPartProxyFactory;
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/Header/HeaderConsts.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | /**
11 |  * List of header name constants.
12 |  *
13 |  * @author Thomas Landauer
14 |  */
15 | abstract class HeaderConsts
16 | {
17 |     // Headers according to the table at https://tools.ietf.org/html/rfc5322#section-3.6
18 |     public const RETURN_PATH = 'Return-Path';
19 | 
20 |     public const RECEIVED = 'Received';
21 | 
22 |     public const RESENT_DATE = 'Resent-Date';
23 | 
24 |     public const RESENT_FROM = 'Resent-From';
25 | 
26 |     public const RESENT_SENDER = 'Resent-Sender';
27 | 
28 |     public const RESENT_TO = 'Resent-To';
29 | 
30 |     public const RESENT_CC = 'Resent-Cc';
31 | 
32 |     public const RESENT_BCC = 'Resent-Bcc';
33 | 
34 |     public const RESENT_MSD_ID = 'Resent-Message-ID';
35 | 
36 |     public const RESENT_MESSAGE_ID = self::RESENT_MSD_ID;
37 | 
38 |     public const ORIG_DATE = 'Date';
39 | 
40 |     public const DATE = self::ORIG_DATE;
41 | 
42 |     public const FROM = 'From';
43 | 
44 |     public const SENDER = 'Sender';
45 | 
46 |     public const REPLY_TO = 'Reply-To';
47 | 
48 |     public const TO = 'To';
49 | 
50 |     public const CC = 'Cc';
51 | 
52 |     public const BCC = 'Bcc';
53 | 
54 |     public const MESSAGE_ID = 'Message-ID';
55 | 
56 |     public const IN_REPLY_TO = 'In-Reply-To';
57 | 
58 |     public const REFERENCES = 'References';
59 | 
60 |     public const SUBJECT = 'Subject';
61 | 
62 |     public const COMMENTS = 'Comments';
63 | 
64 |     public const KEYWORDS = 'Keywords';
65 | 
66 |     // https://datatracker.ietf.org/doc/html/rfc4021#section-2.2
67 |     public const MIME_VERSION = 'MIME-Version';
68 | 
69 |     public const CONTENT_TYPE = 'Content-Type';
70 | 
71 |     public const CONTENT_TRANSFER_ENCODING = 'Content-Transfer-Encoding';
72 | 
73 |     public const CONTENT_ID = 'Content-ID';
74 | 
75 |     public const CONTENT_DESCRIPTION = 'Content-Description';
76 | 
77 |     public const CONTENT_DISPOSITION = 'Content-Disposition';
78 | 
79 |     public const CONTENT_LANGUAGE = 'Content-Language';
80 | 
81 |     public const CONTENT_BASE = 'Content-Base';
82 | 
83 |     public const CONTENT_LOCATION = 'Content-Location';
84 | 
85 |     public const CONTENT_FEATURES = 'Content-features';
86 | 
87 |     public const CONTENT_ALTERNATIVE = 'Content-Alternative';
88 | 
89 |     public const CONTENT_MD5 = 'Content-MD5';
90 | 
91 |     public const CONTENT_DURATION = 'Content-Duration';
92 | 
93 |     // https://datatracker.ietf.org/doc/html/rfc3834
94 |     public const AUTO_SUBMITTED = 'Auto-Submitted';
95 | }
96 | 


--------------------------------------------------------------------------------
/src/Header/IHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header;
 9 | 
10 | use ZBateson\MailMimeParser\IErrorBag;
11 | 
12 | /**
13 |  * A mime email header line consisting of a name and value.
14 |  *
15 |  * The header object provides methods to access the header's name, raw value,
16 |  * and also its parsed value.  The parsed value will depend on the type of
17 |  * header and in some cases may be broken up into other parts (for example email
18 |  * addresses in an address header, or parameters in a parameter header).
19 |  *
20 |  * @author Zaahid Bateson
21 |  */
22 | interface IHeader extends IErrorBag
23 | {
24 |     /**
25 |      * Returns an array of IHeaderPart objects the header's value has been
26 |      * parsed into, excluding any
27 |      * {@see \ZBateson\MailMimeParser\Header\Part\CommentPart}s.
28 |      *
29 |      * To retrieve all parts /including/ CommentParts, {@see getAllParts()}.
30 |      *
31 |      * @return IHeaderPart[] The array of parts.
32 |      */
33 |     public function getParts() : array;
34 | 
35 |     /**
36 |      * Returns an array of all IHeaderPart objects the header's value has been
37 |      * parsed into, including any CommentParts.
38 |      *
39 |      * @return IHeaderPart[] The array of parts.
40 |      */
41 |     public function getAllParts() : array;
42 | 
43 |     /**
44 |      * Returns an array of comments parsed from the header.  If there are no
45 |      * comments in the header, an empty array is returned.
46 |      *
47 |      * @return string[]
48 |      */
49 |     public function getComments() : array;
50 | 
51 |     /**
52 |      * Returns the parsed 'value' of the header.
53 |      *
54 |      * For headers that contain multiple parts, like address headers (To, From)
55 |      * or parameter headers (Content-Type), the 'value' is the value of the
56 |      * first parsed part that isn't a comment.
57 |      *
58 |      * @return string The value
59 |      */
60 |     public function getValue() : ?string;
61 | 
62 |     /**
63 |      * Returns the raw value of the header.
64 |      *
65 |      * @return string The raw value.
66 |      */
67 |     public function getRawValue() : string;
68 | 
69 |     /**
70 |      * Returns the name of the header.
71 |      *
72 |      * @return string The name.
73 |      */
74 |     public function getName() : string;
75 | 
76 |     /**
77 |      * Returns the string representation of the header.
78 |      *
79 |      * i.e.: '<HeaderName>: <RawValue>'
80 |      *
81 |      * @return string The string representation.
82 |      */
83 |     public function __toString() : string;
84 | }
85 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/IdBaseConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\IHeaderPart;
12 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
13 | 
14 | /**
15 |  * Serves as a base-consumer for ID headers (like Message-ID and Content-ID).
16 |  *
17 |  * IdBaseConsumerService handles invalidly-formatted IDs not within '<' and '>'
18 |  * characters.  Processing for validly-formatted IDs are passed on to its
19 |  * sub-consumer, IdConsumer.
20 |  *
21 |  * @author Zaahid Bateson
22 |  */
23 | class IdBaseConsumerService extends AbstractConsumerService
24 | {
25 |     public function __construct(
26 |         LoggerInterface $logger,
27 |         HeaderPartFactory $partFactory,
28 |         CommentConsumerService $commentConsumerService,
29 |         QuotedStringConsumerService $quotedStringConsumerService,
30 |         IdConsumerService $idConsumerService
31 |     ) {
32 |         parent::__construct(
33 |             $logger,
34 |             $partFactory,
35 |             [
36 |                 $commentConsumerService,
37 |                 $quotedStringConsumerService,
38 |                 $idConsumerService
39 |             ]
40 |         );
41 |     }
42 | 
43 |     /**
44 |      * Returns '\s+' as a whitespace separator.
45 |      *
46 |      * @return string[] an array of regex pattern matchers.
47 |      */
48 |     protected function getTokenSeparators() : array
49 |     {
50 |         return ['\s+'];
51 |     }
52 | 
53 |     /**
54 |      * IdBaseConsumerService doesn't have start/end tokens, and so always
55 |      * returns false.
56 |      */
57 |     protected function isEndToken(string $token) : bool
58 |     {
59 |         return false;
60 |     }
61 | 
62 |     /**
63 |      * IdBaseConsumerService doesn't have start/end tokens, and so always
64 |      * returns false.
65 |      *
66 |      * @codeCoverageIgnore
67 |      */
68 |     protected function isStartToken(string $token) : bool
69 |     {
70 |         return false;
71 |     }
72 | 
73 |     /**
74 |      * Returns null for whitespace, and
75 |      * {@see ZBateson\MailMimeParser\Header\Part\Token} for anything else.
76 |      *
77 |      * @param string $token the token
78 |      * @param bool $isLiteral set to true if the token represents a literal -
79 |      *        e.g. an escaped token
80 |      * @return ?IHeaderPart The constructed header part or null if the token
81 |      *         should be ignored
82 |      */
83 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
84 |     {
85 |         if (\preg_match('/^\s+$/', $token)) {
86 |             return null;
87 |         }
88 |         return $this->partFactory->newToken($token, true);
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserMessageProxyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the ZBateson\MailMimeParser project.
 5 |  *
 6 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 7 |  */
 8 | 
 9 | namespace ZBateson\MailMimeParser\Parser\Proxy;
10 | 
11 | use Psr\Log\LoggerInterface;
12 | use ZBateson\MailMimeParser\Message;
13 | use ZBateson\MailMimeParser\Message\Factory\PartHeaderContainerFactory;
14 | use ZBateson\MailMimeParser\Message\Helper\MultipartHelper;
15 | use ZBateson\MailMimeParser\Message\Helper\PrivacyHelper;
16 | use ZBateson\MailMimeParser\Parser\IParserService;
17 | use ZBateson\MailMimeParser\Parser\Part\ParserPartChildrenContainerFactory;
18 | use ZBateson\MailMimeParser\Parser\Part\ParserPartStreamContainerFactory;
19 | use ZBateson\MailMimeParser\Parser\PartBuilder;
20 | use ZBateson\MailMimeParser\Stream\StreamFactory;
21 | 
22 | /**
23 |  * Responsible for creating proxied IMessage instances wrapped in a
24 |  * ParserMessageProxy.
25 |  *
26 |  * @author Zaahid Bateson
27 |  */
28 | class ParserMessageProxyFactory extends ParserMimePartProxyFactory
29 | {
30 |     protected MultipartHelper $multipartHelper;
31 | 
32 |     protected PrivacyHelper $privacyHelper;
33 | 
34 |     public function __construct(
35 |         LoggerInterface $logger,
36 |         StreamFactory $sdf,
37 |         PartHeaderContainerFactory $phcf,
38 |         ParserPartStreamContainerFactory $pscf,
39 |         ParserPartChildrenContainerFactory $ppccf,
40 |         MultipartHelper $multipartHelper,
41 |         PrivacyHelper $privacyHelper
42 |     ) {
43 |         parent::__construct($logger, $sdf, $phcf, $pscf, $ppccf);
44 |         $this->multipartHelper = $multipartHelper;
45 |         $this->privacyHelper = $privacyHelper;
46 |     }
47 | 
48 |     /**
49 |      * Constructs a new ParserMessageProxy wrapping an IMessage object that will
50 |      * dynamically parse a message's content and parts as they're requested.
51 |      */
52 |     public function newInstance(PartBuilder $partBuilder, IParserService $parser) : ParserMessageProxy
53 |     {
54 |         $parserProxy = new ParserMessageProxy($partBuilder, $parser);
55 | 
56 |         $streamContainer = $this->parserPartStreamContainerFactory->newInstance($parserProxy);
57 |         $headerContainer = $this->partHeaderContainerFactory->newInstance($parserProxy->getHeaderContainer());
58 |         $childrenContainer = $this->parserPartChildrenContainerFactory->newInstance($parserProxy);
59 | 
60 |         $message = new Message(
61 |             $this->logger,
62 |             $streamContainer,
63 |             $headerContainer,
64 |             $childrenContainer,
65 |             $this->multipartHelper,
66 |             $this->privacyHelper
67 |         );
68 |         $parserProxy->setPart($message);
69 | 
70 |         $streamContainer->setStream($this->streamFactory->newMessagePartStream($message));
71 |         $message->attach($streamContainer);
72 |         return $parserProxy;
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserMimePartProxyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser\Proxy;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Message\Factory\PartHeaderContainerFactory;
12 | use ZBateson\MailMimeParser\Message\MimePart;
13 | use ZBateson\MailMimeParser\Parser\IParserService;
14 | use ZBateson\MailMimeParser\Parser\Part\ParserPartChildrenContainerFactory;
15 | use ZBateson\MailMimeParser\Parser\Part\ParserPartStreamContainerFactory;
16 | use ZBateson\MailMimeParser\Parser\PartBuilder;
17 | use ZBateson\MailMimeParser\Stream\StreamFactory;
18 | 
19 | /**
20 |  * Responsible for creating proxied IMimePart instances wrapped in a
21 |  * ParserMimePartProxy with a MimeParser.
22 |  *
23 |  * @author Zaahid Bateson
24 |  */
25 | class ParserMimePartProxyFactory extends ParserPartProxyFactory
26 | {
27 |     protected LoggerInterface $logger;
28 | 
29 |     protected StreamFactory $streamFactory;
30 | 
31 |     protected ParserPartStreamContainerFactory $parserPartStreamContainerFactory;
32 | 
33 |     protected PartHeaderContainerFactory $partHeaderContainerFactory;
34 | 
35 |     protected ParserPartChildrenContainerFactory $parserPartChildrenContainerFactory;
36 | 
37 |     public function __construct(
38 |         LoggerInterface $logger,
39 |         StreamFactory $sdf,
40 |         PartHeaderContainerFactory $phcf,
41 |         ParserPartStreamContainerFactory $pscf,
42 |         ParserPartChildrenContainerFactory $ppccf
43 |     ) {
44 |         $this->logger = $logger;
45 |         $this->streamFactory = $sdf;
46 |         $this->partHeaderContainerFactory = $phcf;
47 |         $this->parserPartStreamContainerFactory = $pscf;
48 |         $this->parserPartChildrenContainerFactory = $ppccf;
49 |     }
50 | 
51 |     /**
52 |      * Constructs a new ParserMimePartProxy wrapping an IMimePart object that
53 |      * will dynamically parse a message's content and parts as they're
54 |      * requested.
55 |      */
56 |     public function newInstance(PartBuilder $partBuilder, IParserService $parser) : ParserMimePartProxy
57 |     {
58 |         $parserProxy = new ParserMimePartProxy($partBuilder, $parser);
59 | 
60 |         $streamContainer = $this->parserPartStreamContainerFactory->newInstance($parserProxy);
61 |         $headerContainer = $this->partHeaderContainerFactory->newInstance($parserProxy->getHeaderContainer());
62 |         $childrenContainer = $this->parserPartChildrenContainerFactory->newInstance($parserProxy);
63 | 
64 |         $part = new MimePart(
65 |             $partBuilder->getParent()->getPart(),
66 |             $this->logger,
67 |             $streamContainer,
68 |             $headerContainer,
69 |             $childrenContainer
70 |         );
71 |         $parserProxy->setPart($part);
72 | 
73 |         $streamContainer->setStream($this->streamFactory->newMessagePartStream($part));
74 |         $part->attach($streamContainer);
75 |         return $parserProxy;
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/Received/DomainConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer\Received;
 9 | 
10 | /**
11 |  * Parses a so-called "extended-domain" (from and by) part of a Received header.
12 |  *
13 |  * Looks for and extracts the following fields from an extended-domain part:
14 |  * Name, Hostname and Address.
15 |  *
16 |  * The Name part is always the portion of the extended-domain part existing on
17 |  * its own, outside of the parenthesized hostname and address part.  This is
18 |  * true regardless of whether an address is used as the name, as its assumed to
19 |  * be the string used to identify the server, whatever it may be.
20 |  *
21 |  * The parenthesized part normally (but not necessarily) following a name must
22 |  * "look like" a tcp-info section of an extended domain as defined by RFC5321.
23 |  * The validation is very purposefully very loose to be accommodating to many
24 |  * erroneous implementations.  The only restriction is the host part must
25 |  * contain two characters, the first being alphanumeric, followed by any number
26 |  * of more alphanumeric, '.', and '-' characters.  The address part must be
27 |  * within square brackets, '[]'... although an address outside of square
28 |  * brackets could be matched by the domain matcher if it exists alone within the
29 |  * parentheses.  The address is any number of '.', numbers, ':' and letters a-f.
30 |  * This allows it to match ipv6 addresses as well.  In addition, the address may
31 |  * start with the string "ipv6", and may be followed by a port number as some
32 |  * implementations seem to do.
33 |  *
34 |  * Strings in parentheses not matching the aforementioned 'domain/address'
35 |  * pattern will be considered comments, and will be returned as a separate
36 |  * CommentPart.
37 |  *
38 |  * @see https://tools.ietf.org/html/rfc5321#section-4.4
39 |  * @see https://github.com/Te-k/pyreceived/blob/master/test.py
40 |  * @author Zaahid Bateson
41 |  * @author Mariusz Krzaczkowski
42 |  */
43 | class DomainConsumerService extends GenericReceivedConsumerService
44 | {
45 |     /**
46 |      * Overridden to return true if the passed token is a closing parenthesis.
47 |      */
48 |     protected function isEndToken(string $token) : bool
49 |     {
50 |         if ($token === ')') {
51 |             return true;
52 |         }
53 |         return parent::isEndToken($token);
54 |     }
55 | 
56 |     /**
57 |      * Creates a single ReceivedDomainPart out of matched parts.  If an
58 |      * unmatched parenthesized expression was found, it's returned as a
59 |      * CommentPart.
60 |      *
61 |      * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
62 |      * @return \ZBateson\MailMimeParser\Header\Part\ReceivedDomainPart[]|\ZBateson\MailMimeParser\Header\Part\CommentPart[]|\ZBateson\MailMimeParser\Header\Part\HeaderPart[]
63 |      */
64 |     protected function processParts(array $parts) : array
65 |     {
66 |         return [$this->partFactory->newReceivedDomainPart($this->partName, $parts)];
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/AddressBaseConsumerService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Consumer;
  9 | 
 10 | use Iterator;
 11 | use Psr\Log\LoggerInterface;
 12 | use ZBateson\MailMimeParser\Header\IHeaderPart;
 13 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
 14 | 
 15 | /**
 16 |  * Serves as a base-consumer for recipient/sender email address headers (like
 17 |  * From and To).
 18 |  *
 19 |  * AddressBaseConsumerService passes on token processing to its sub-consumer, an
 20 |  * AddressConsumerService, and collects Part\AddressPart objects processed and
 21 |  * returned by AddressConsumerService.
 22 |  *
 23 |  * @author Zaahid Bateson
 24 |  */
 25 | class AddressBaseConsumerService extends AbstractConsumerService
 26 | {
 27 |     public function __construct(
 28 |         LoggerInterface $logger,
 29 |         HeaderPartFactory $partFactory,
 30 |         AddressConsumerService $addressConsumerService
 31 |     ) {
 32 |         parent::__construct($logger, $partFactory, [$addressConsumerService]);
 33 |     }
 34 | 
 35 |     /**
 36 |      * Returns an empty array.
 37 |      *
 38 |      * @return string[] an array of regex pattern matchers
 39 |      */
 40 |     protected function getTokenSeparators() : array
 41 |     {
 42 |         return [];
 43 |     }
 44 | 
 45 |     /**
 46 |      * Disables advancing for start tokens.
 47 |      *
 48 |      * The start token for AddressBaseConsumerService is part of an
 49 |      * {@see AddressPart} (or a sub-consumer) and so must be passed on.
 50 |      */
 51 |     protected function advanceToNextToken(Iterator $tokens, bool $isStartToken) : static
 52 |     {
 53 |         if ($isStartToken) {
 54 |             return $this;
 55 |         }
 56 |         parent::advanceToNextToken($tokens, $isStartToken);
 57 |         return $this;
 58 |     }
 59 | 
 60 |     /**
 61 |      * AddressBaseConsumerService doesn't have start/end tokens, and so always
 62 |      * returns false.
 63 |      *
 64 |      * @return false
 65 |      */
 66 |     protected function isEndToken(string $token) : bool
 67 |     {
 68 |         return false;
 69 |     }
 70 | 
 71 |     /**
 72 |      * AddressBaseConsumerService doesn't have start/end tokens, and so always
 73 |      * returns false.
 74 |      *
 75 |      * @codeCoverageIgnore
 76 |      * @return false
 77 |      */
 78 |     protected function isStartToken(string $token) : bool
 79 |     {
 80 |         return false;
 81 |     }
 82 | 
 83 |     /**
 84 |      * Overridden so tokens aren't handled at this level, and instead are passed
 85 |      * on to AddressConsumerService.
 86 |      *
 87 |      * @return \ZBateson\MailMimeParser\Header\IHeaderPart[]|array
 88 |      */
 89 |     protected function getTokenParts(Iterator $tokens) : array
 90 |     {
 91 |         return $this->getConsumerTokenParts($tokens);
 92 |     }
 93 | 
 94 |     /**
 95 |      * Never reached by AddressBaseConsumerService. Overridden to satisfy
 96 |      * AbstractConsumerService.
 97 |      *
 98 |      * @codeCoverageIgnore
 99 |      */
100 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
101 |     {
102 |         return null;
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/src/Parser/MessageParserService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser;
 9 | 
10 | use Psr\Http\Message\StreamInterface;
11 | use ZBateson\MailMimeParser\IMessage;
12 | use ZBateson\MailMimeParser\Message\Factory\PartHeaderContainerFactory;
13 | 
14 | /**
15 |  * Parses a mail mime message into its component parts.  To invoke, call
16 |  * {@see MailMimeParser::parse()}.
17 |  *
18 |  * @author Zaahid Bateson
19 |  */
20 | class MessageParserService
21 | {
22 |     /**
23 |      * @var PartHeaderContainerFactory To create a container to read the
24 |      *      message's headers into.
25 |      */
26 |     protected PartHeaderContainerFactory $partHeaderContainerFactory;
27 | 
28 |     /**
29 |      * @var ParserManagerService To figure out what parser is responsible for parsing a
30 |      *      message.
31 |      */
32 |     protected ParserManagerService $parserManager;
33 | 
34 |     /**
35 |      * @var PartBuilderFactory To create a PartBuilder representing this
36 |      *      message, and to pass it to ParserManager.
37 |      */
38 |     protected PartBuilderFactory $partBuilderFactory;
39 | 
40 |     /**
41 |      * @var HeaderParserService To parse the headers into a PartHeaderContainer.
42 |      */
43 |     protected HeaderParserService $headerParser;
44 | 
45 |     public function __construct(
46 |         PartBuilderFactory $pbf,
47 |         PartHeaderContainerFactory $phcf,
48 |         ParserManagerService $pm,
49 |         HeaderParserService $hp
50 |     ) {
51 |         $this->partBuilderFactory = $pbf;
52 |         $this->partHeaderContainerFactory = $phcf;
53 |         $this->parserManager = $pm;
54 |         $this->headerParser = $hp;
55 |     }
56 | 
57 |     /**
58 |      * Convenience method to read a line of up to 4096 characters from the
59 |      * passed resource handle.
60 |      *
61 |      * If the line is larger than 4096 characters, the remaining characters in
62 |      * the line are read and discarded, and only the first 4096 characters are
63 |      * returned.
64 |      *
65 |      * @param resource $handle
66 |      * @return string|false the read line or false on EOF or on error.
67 |      */
68 |     public static function readLine($handle) : string|false
69 |     {
70 |         $size = 4096;
71 |         $ret = $line = \fgets($handle, $size);
72 |         while (\strlen($line) === $size - 1 && \substr($line, -1) !== "\n") {
73 |             $line = \fgets($handle, $size);
74 |         }
75 |         return $ret;
76 |     }
77 | 
78 |     /**
79 |      * Parses the passed stream into an {@see ZBateson\MailMimeParser\IMessage}
80 |      * object and returns it.
81 |      *
82 |      * @param StreamInterface $stream the stream to parse the message from
83 |      */
84 |     public function parse(StreamInterface $stream) : IMessage
85 |     {
86 |         $headerContainer = $this->partHeaderContainerFactory->newInstance();
87 |         $partBuilder = $this->partBuilderFactory->newPartBuilder($headerContainer, $stream);
88 |         $this->headerParser->parse(
89 |             $partBuilder->getMessageResourceHandle(),
90 |             $headerContainer
91 |         );
92 |         $proxy = $this->parserManager->createParserProxyFor($partBuilder);
93 |         return $proxy->getPart();
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserNonMimeMessageProxy.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Parser\Proxy;
  9 | 
 10 | /**
 11 |  * A bi-directional parser-to-part proxy for IMessage objects created by
 12 |  * NonMimeParser.
 13 |  *
 14 |  * @author Zaahid Bateson
 15 |  */
 16 | class ParserNonMimeMessageProxy extends ParserMessageProxy
 17 | {
 18 |     /**
 19 |      * @var ?int The next part's start position within the message's raw stream
 20 |      *      or null if not set, not discovered, or there are no more parts.
 21 |      */
 22 |     protected ?int $nextPartStart = null;
 23 | 
 24 |     /**
 25 |      * @var ?int The next part's unix file mode in a uu-encoded 'begin' line if
 26 |      *      exists, or null otherwise.
 27 |      */
 28 |     protected ?int $nextPartMode = null;
 29 | 
 30 |     /**
 31 |      * @var ?string The next part's file name in a uu-encoded 'begin' line if
 32 |      *      exists, or null otherwise.
 33 |      */
 34 |     protected ?string $nextPartFilename = null;
 35 | 
 36 |     /**
 37 |      * Returns the next part's start position within the message's raw stream,
 38 |      * or null if not set, not discovered, or there are no more parts under this
 39 |      * message.
 40 |      *
 41 |      * @return int|null The start position or null
 42 |      */
 43 |     public function getNextPartStart() : ?int
 44 |     {
 45 |         return $this->nextPartStart;
 46 |     }
 47 | 
 48 |     /**
 49 |      * Returns the next part's unix file mode in a uu-encoded 'begin' line if
 50 |      * one exists, or null otherwise.
 51 |      *
 52 |      * @return int|null The file mode or null
 53 |      */
 54 |     public function getNextPartMode() : ?int
 55 |     {
 56 |         return $this->nextPartMode;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Returns the next part's filename in a uu-encoded 'begin' line if one
 61 |      * exists, or null otherwise.
 62 |      *
 63 |      * @return string|null The file name or null
 64 |      */
 65 |     public function getNextPartFilename() : ?string
 66 |     {
 67 |         return $this->nextPartFilename;
 68 |     }
 69 | 
 70 |     /**
 71 |      * Sets the next part's start position within the message's raw stream.
 72 |      */
 73 |     public function setNextPartStart(int $nextPartStart) : static
 74 |     {
 75 |         $this->nextPartStart = $nextPartStart;
 76 |         return $this;
 77 |     }
 78 | 
 79 |     /**
 80 |      * Sets the next part's unix file mode from its 'begin' line.
 81 |      */
 82 |     public function setNextPartMode(int $nextPartMode) : static
 83 |     {
 84 |         $this->nextPartMode = $nextPartMode;
 85 |         return $this;
 86 |     }
 87 | 
 88 |     /**
 89 |      * Sets the next part's filename from its 'begin' line.
 90 |      *
 91 |      */
 92 |     public function setNextPartFilename(string $nextPartFilename) : static
 93 |     {
 94 |         $this->nextPartFilename = $nextPartFilename;
 95 |         return $this;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Sets the next part start position, file mode, and filename to null
100 |      */
101 |     public function clearNextPart() : static
102 |     {
103 |         $this->nextPartStart = null;
104 |         $this->nextPartMode = null;
105 |         $this->nextPartFilename = null;
106 |         return $this;
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/src/Message/UUEncodedPart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Message;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MailMimeParser\MailMimeParser;
 12 | 
 13 | /**
 14 |  * Implementation of a non-mime message's uuencoded attachment part.
 15 |  *
 16 |  * @author Zaahid Bateson
 17 |  */
 18 | class UUEncodedPart extends NonMimePart implements IUUEncodedPart
 19 | {
 20 |     /**
 21 |      * @var int the unix file permission
 22 |      */
 23 |     protected ?int $mode = null;
 24 | 
 25 |     /**
 26 |      * @var string the name of the file in the uuencoding 'header'.
 27 |      */
 28 |     protected ?string $filename = null;
 29 | 
 30 |     public function __construct(
 31 |         ?int $mode = null,
 32 |         ?string $filename = null,
 33 |         ?IMimePart $parent = null,
 34 |         ?LoggerInterface $logger = null,
 35 |         ?PartStreamContainer $streamContainer = null
 36 |     ) {
 37 |         $di = MailMimeParser::getGlobalContainer();
 38 |         parent::__construct(
 39 |             $logger ?? $di->get(LoggerInterface::class),
 40 |             $streamContainer ?? $di->get(PartStreamContainer::class),
 41 |             $parent
 42 |         );
 43 |         $this->mode = $mode;
 44 |         $this->filename = $filename;
 45 |     }
 46 | 
 47 |     /**
 48 |      * Returns the filename included in the uuencoded 'begin' line for this
 49 |      * part.
 50 |      */
 51 |     public function getFilename() : ?string
 52 |     {
 53 |         return $this->filename;
 54 |     }
 55 | 
 56 |     public function setFilename(string $filename) : static
 57 |     {
 58 |         $this->filename = $filename;
 59 |         $this->notify();
 60 |         return $this;
 61 |     }
 62 | 
 63 |     /**
 64 |      * Returns false.
 65 |      *
 66 |      * Although the part may be plain text, there is no reliable way of
 67 |      * determining its type since uuencoded 'begin' lines only include a file
 68 |      * name and no mime type.  The file name's extension may be a hint.
 69 |      *
 70 |      * @return false
 71 |      */
 72 |     public function isTextPart() : bool
 73 |     {
 74 |         return false;
 75 |     }
 76 | 
 77 |     /**
 78 |      * Returns 'application/octet-stream'.
 79 |      */
 80 |     public function getContentType(string $default = 'application/octet-stream') : ?string
 81 |     {
 82 |         return 'application/octet-stream';
 83 |     }
 84 | 
 85 |     /**
 86 |      * Returns null
 87 |      */
 88 |     public function getCharset() : ?string
 89 |     {
 90 |         return null;
 91 |     }
 92 | 
 93 |     /**
 94 |      * Returns 'attachment'.
 95 |      */
 96 |     public function getContentDisposition(?string $default = 'attachment') : ?string
 97 |     {
 98 |         return 'attachment';
 99 |     }
100 | 
101 |     /**
102 |      * Returns 'x-uuencode'.
103 |      */
104 |     public function getContentTransferEncoding(?string $default = 'x-uuencode') : ?string
105 |     {
106 |         return 'x-uuencode';
107 |     }
108 | 
109 |     public function getUnixFileMode() : ?int
110 |     {
111 |         return $this->mode;
112 |     }
113 | 
114 |     public function setUnixFileMode(int $mode) : static
115 |     {
116 |         $this->mode = $mode;
117 |         $this->notify();
118 |         return $this;
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------
/src/Stream/HeaderStream.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Stream;
  9 | 
 10 | use ArrayIterator;
 11 | use GuzzleHttp\Psr7;
 12 | use Psr\Http\Message\StreamInterface;
 13 | use SplObserver;
 14 | use SplSubject;
 15 | use Traversable;
 16 | use ZBateson\MailMimeParser\Header\HeaderConsts;
 17 | use ZBateson\MailMimeParser\Message\IMessagePart;
 18 | use ZBateson\MailMimeParser\Message\IMimePart;
 19 | 
 20 | /**
 21 |  * Psr7 stream decorator implementation providing a readable stream for a part's
 22 |  * headers.
 23 |  *
 24 |  * HeaderStream is only used by a MimePart parent.  It can accept any
 25 |  * MessagePart - for non-MimeParts, only type headers are generated based on
 26 |  * available information.
 27 |  *
 28 |  * @author Zaahid Bateson
 29 |  */
 30 | class HeaderStream extends MessagePartStreamDecorator implements SplObserver, StreamInterface
 31 | {
 32 |     /**
 33 |      * @var IMessagePart the part to read from.
 34 |      */
 35 |     protected IMessagePart $part;
 36 | 
 37 |     public function __construct(IMessagePart $part)
 38 |     {
 39 |         parent::__construct($part);
 40 |         $part->attach($this);
 41 | 
 42 |         // unsetting the property forces the first access to go through
 43 |         // __get().
 44 |         unset($this->stream);
 45 |     }
 46 | 
 47 |     public function __destruct()
 48 |     {
 49 |         $this->part->detach($this);
 50 |     }
 51 | 
 52 |     public function update(SplSubject $subject) : void
 53 |     {
 54 |         if ($this->stream !== null) {
 55 |             $this->stream = $this->createStream();
 56 |         }
 57 |     }
 58 | 
 59 |     /**
 60 |      * Returns a header array for the current part.
 61 |      *
 62 |      * If the part is not a MimePart, Content-Type, Content-Disposition and
 63 |      * Content-Transfer-Encoding headers are generated manually.
 64 |      */
 65 |     private function getPartHeadersIterator() : Traversable
 66 |     {
 67 |         if ($this->part instanceof IMimePart) {
 68 |             return $this->part->getRawHeaderIterator();
 69 |         } elseif ($this->part->getParent() !== null && $this->part->getParent()->isMime()) {
 70 |             return new ArrayIterator([
 71 |                 [HeaderConsts::CONTENT_TYPE, $this->part->getContentType()],
 72 |                 [HeaderConsts::CONTENT_DISPOSITION, $this->part->getContentDisposition()],
 73 |                 [HeaderConsts::CONTENT_TRANSFER_ENCODING, $this->part->getContentTransferEncoding()]
 74 |             ]);
 75 |         }
 76 |         return new ArrayIterator();
 77 |     }
 78 | 
 79 |     /**
 80 |      * Writes out headers for $this->part and follows them with an empty line.
 81 |      */
 82 |     public function writePartHeadersTo(StreamInterface $stream) : static
 83 |     {
 84 |         foreach ($this->getPartHeadersIterator() as $header) {
 85 |             $stream->write("{$header[0]}: {$header[1]}\r\n");
 86 |         }
 87 |         $stream->write("\r\n");
 88 |         return $this;
 89 |     }
 90 | 
 91 |     /**
 92 |      * Creates the underlying stream lazily when required.
 93 |      */
 94 |     protected function createStream() : StreamInterface
 95 |     {
 96 |         $stream = Psr7\Utils::streamFor();
 97 |         $this->writePartHeadersTo($stream);
 98 |         $stream->rewind();
 99 |         return $stream;
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/src/IErrorBag.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser;
 9 | 
10 | use Psr\Log\LogLevel;
11 | use Throwable;
12 | 
13 | /**
14 |  * Defines an object that may contain a set of errors, and optionally perform
15 |  * additional validation.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | interface IErrorBag
20 | {
21 |     /**
22 |      * Returns a context name for the current object to help identify it in
23 |      * logs.
24 |      */
25 |     public function getErrorLoggingContextName() : string;
26 | 
27 |     /**
28 |      * Creates and adds an Error object to this ErrorBag.
29 |      */
30 |     public function addError(string $message, string $psrLogLevel, ?Throwable $exception = null) : static;
31 | 
32 |     /**
33 |      * Returns true if this object has an error in its error bag at or above
34 |      * the passed $minPsrLevel (defaults to ERROR).  If $validate is true,
35 |      * additional validation may be performed.
36 |      *
37 |      * The PSR levels are defined in Psr\Log\LogLevel.
38 |      */
39 |     public function hasErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : bool;
40 | 
41 |     /**
42 |      * Returns any local errors this object has at or above the passed PSR log
43 |      * level in Psr\Log\LogLevel (defaulting to LogLevel::ERROR).
44 |      *
45 |      * If $validate is true, additional validation may be performed on the
46 |      * object to check for errors.
47 |      *
48 |      * @return Error[]
49 |      */
50 |     public function getErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : array;
51 | 
52 |     /**
53 |      * Returns true if there are errors on this object, or any IErrorBag child
54 |      * of this object at or above the passed PSR log level in Psr\Log\LogLevel
55 |      * (defaulting to LogLevel::ERROR).  Note that this will stop after finding
56 |      * the first error and return, so may be slightly more performant if an
57 |      * error actually exists over calling getAllErrors if only interested in
58 |      * whether an error exists.
59 |      *
60 |      * Care should be taken using this if the intention is to only 'preview' a
61 |      * message without parsing it entirely, since this will cause the whole
62 |      * message to be parsed as it traverses children, and could be slow on
63 |      * messages with large attachments, etc...
64 |      *
65 |      * If $validate is true, additional validation may be performed to check for
66 |      * errors.
67 |      */
68 |     public function hasAnyErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : bool;
69 | 
70 |     /**
71 |      * Returns any errors on this object, and all IErrorBag children of this
72 |      * object at or above the passed PSR log level from Psr\Log\LogLevel
73 |      * (defaulting to LogLevel::ERROR).
74 |      *
75 |      * Care should be taken using this if the intention is to only 'preview' a
76 |      * message without parsing it entirely, since this will cause the whole
77 |      * message to be parsed as it traverses children, and could be slow on
78 |      * messages with large attachments, etc...
79 |      *
80 |      * If $validate is true, additional validation may be performed on children
81 |      * to check for errors.
82 |      *
83 |      * @return Error[]
84 |      */
85 |     public function getAllErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : array;
86 | }
87 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/ParameterNameValueConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Psr\Log\LoggerInterface;
11 | use ZBateson\MailMimeParser\Header\IHeaderPart;
12 | use ZBateson\MailMimeParser\Header\Part\ContainerPart;
13 | use ZBateson\MailMimeParser\Header\Part\MimeTokenPartFactory;
14 | 
15 | /**
16 |  * Parses an individual part of a parameter header.
17 |  *
18 |  * 'isStartToken' always returns true, so control is taken from
19 |  * ParameterConsumerService always, and returned when a ';' is encountered (and
20 |  * so processes a single part and returns it, then gets control back).0
21 |  *
22 |  * If an '=' is encountered, the ParameterValueConsumerService sub-consumer
23 |  * takes control and parses the value of a parameter.
24 |  *
25 |  * If no '=' is encountered, it's assumed to be a single value element, which
26 |  * should be the first part of a parameter header, e.g. 'text/html' in
27 |  * Content-Type: text/html; charset=utf-8
28 |  *
29 |  * @author Zaahid Bateson
30 |  */
31 | class ParameterNameValueConsumerService extends AbstractGenericConsumerService
32 | {
33 |     public function __construct(
34 |         LoggerInterface $logger,
35 |         MimeTokenPartFactory $partFactory,
36 |         ParameterValueConsumerService $parameterValueConsumerService,
37 |         CommentConsumerService $commentConsumerService,
38 |         QuotedStringConsumerService $quotedStringConsumerService
39 |     ) {
40 |         parent::__construct(
41 |             $logger,
42 |             $partFactory,
43 |             [$parameterValueConsumerService, $commentConsumerService, $quotedStringConsumerService]
44 |         );
45 |     }
46 | 
47 |     /**
48 |      * Returns semi-colon as a token separator, in addition to parent token
49 |      * separators.
50 |      *
51 |      * @return string[]
52 |      */
53 |     protected function getTokenSeparators() : array
54 |     {
55 |         return \array_merge(parent::getTokenSeparators(), [';']);
56 |     }
57 | 
58 |     /**
59 |      * Always returns true to grab control from its parent
60 |      * ParameterConsumerService.
61 |      */
62 |     protected function isStartToken(string $token) : bool
63 |     {
64 |         return true;
65 |     }
66 | 
67 |     /**
68 |      * Returns true if the token is a ';' char.
69 |      */
70 |     protected function isEndToken(string $token) : bool
71 |     {
72 |         return ($token === ';');
73 |     }
74 | 
75 |     /**
76 |      * Creates either a ContainerPart if an '=' wasn't encountered, indicating
77 |      * this to be the main 'value' part of a header (or a malformed part of a
78 |      * parameter header), or a ParameterPart if the last IHeaderPart in the
79 |      * passed $parts array is already a ContainerPart (indicating it was parsed
80 |      * in ParameterValueConsumerService.)
81 |      *
82 |      * @param IHeaderPart[] $parts The parsed parts.
83 |      * @return IHeaderPart[] Array of resulting final parts.
84 |      */
85 |     protected function processParts(array $parts) : array
86 |     {
87 |         $nameOnly = $parts;
88 |         $valuePart = \array_pop($nameOnly);
89 |         if (!($valuePart instanceof ContainerPart)) {
90 |             return [$this->partFactory->newContainerPart($parts)];
91 |         }
92 |         return [$this->partFactory->newParameterPart(
93 |             $nameOnly,
94 |             $valuePart
95 |         )];
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/Parser/ParserManagerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser;
 9 | 
10 | use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxy;
11 | 
12 | /**
13 |  * Manages a prioritized list of IParser objects for parsing messages and parts
14 |  * and creating proxied parts.
15 |  *
16 |  * The default ParserManager sets up a MimeParser in priority 0, and a
17 |  * NonMimeParser in priority 1.
18 |  *
19 |  * @author Zaahid Bateson
20 |  */
21 | class ParserManagerService
22 | {
23 |     /**
24 |      * @var IParserService[] List of parsers in order of priority (0 is highest
25 |      *      priority).
26 |      */
27 |     protected array $parsers = [];
28 | 
29 |     public function __construct(MimeParserService $mimeParser, NonMimeParserService $nonMimeParser)
30 |     {
31 |         $this->setParsers([$mimeParser, $nonMimeParser]);
32 |     }
33 | 
34 |     /**
35 |      * Overrides the internal prioritized list of parses with the passed list,
36 |      * calling $parser->setParserManager($this) on each one.
37 |      *
38 |      * @param IParserService[] $parsers
39 |      */
40 |     public function setParsers(array $parsers) : static
41 |     {
42 |         foreach ($parsers as $parser) {
43 |             $parser->setParserManager($this);
44 |         }
45 |         $this->parsers = $parsers;
46 |         return $this;
47 |     }
48 | 
49 |     /**
50 |      * Adds an IParser at the highest priority (up front), calling
51 |      * $parser->setParserManager($this) on it.
52 |      *
53 |      * @param IParserService $parser The parser to add.
54 |      */
55 |     public function prependParser(IParserService $parser) : static
56 |     {
57 |         $parser->setParserManager($this);
58 |         \array_unshift($this->parsers, $parser);
59 |         return $this;
60 |     }
61 | 
62 |     /**
63 |      * Creates a ParserPartProxy for the passed $partBuilder using a compatible
64 |      * IParser.
65 |      *
66 |      * Loops through registered IParsers calling 'canParse()' on each with the
67 |      * passed PartBuilder, then calling either 'getParserMessageProxyFactory()'
68 |      * or 'getParserPartProxyFactory()' depending on if the PartBuilder has a
69 |      * parent, and finally calling 'newInstance' on the returned
70 |      * ParserPartProxyFactory passing it the IParser, and returning the new
71 |      * ParserPartProxy instance that was created.
72 |      *
73 |      * @param PartBuilder $partBuilder The PartBuilder to wrap in a proxy with
74 |      *        an IParser
75 |      * @throws CompatibleParserNotFoundException if a compatible parser for the
76 |      *         type is not configured.
77 |      * @return ParserPartProxy The created ParserPartProxy tied to a new
78 |      *         IMessagePart and associated IParser.
79 |      */
80 |     public function createParserProxyFor(PartBuilder $partBuilder) : ParserPartProxy
81 |     {
82 |         foreach ($this->parsers as $parser) {
83 |             if ($parser->canParse($partBuilder)) {
84 |                 $factory = ($partBuilder->getParent() === null) ?
85 |                     $parser->getParserMessageProxyFactory() :
86 |                     $parser->getParserPartProxyFactory();
87 |                 return $factory->newInstance($partBuilder, $parser);
88 |             }
89 |         }
90 |         throw new CompatibleParserNotFoundException('Compatible parser for a part cannot be found with content-type: ' . $partBuilder->getHeaderContainer()->get('Content-Type'));
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/AddressGroupConsumerService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Consumer;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use Iterator;
 12 | use ZBateson\MailMimeParser\Header\Part\AddressGroupPart;
 13 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
 14 | 
 15 | /**
 16 |  * Parses a single group of addresses (as a named-group part of an address
 17 |  * header).
 18 |  *
 19 |  * Finds addresses using its AddressConsumerService sub-consumer separated by
 20 |  * commas, and ends processing once a semi-colon is found.
 21 |  *
 22 |  * Prior to returning to its calling client, AddressGroupConsumerService
 23 |  * constructs a single Part\AddressGroupPart object filling it with all located
 24 |  * addresses, and returns it.
 25 |  *
 26 |  * The AddressGroupConsumerService extends AddressBaseConsumerService to define
 27 |  * start/end tokens, token separators, and construct a Part\AddressGroupPart to
 28 |  * return.
 29 |  *
 30 |  * @author Zaahid Bateson
 31 |  */
 32 | class AddressGroupConsumerService extends AddressBaseConsumerService
 33 | {
 34 |     public function __construct(LoggerInterface $logger, HeaderPartFactory $partFactory)
 35 |     {
 36 |         AbstractConsumerService::__construct($logger, $partFactory, []);
 37 |     }
 38 | 
 39 |     /**
 40 |      * Needs to be called in AddressConsumerService's constructor to avoid a
 41 |      * circular dependency.
 42 |      *
 43 |      */
 44 |     public function setAddressConsumerService(AddressConsumerService $subConsumer) : void
 45 |     {
 46 |         $this->subConsumers = [$subConsumer];
 47 |     }
 48 | 
 49 |     /**
 50 |      * Overridden to return patterns matching the beginning and end markers of a
 51 |      * group address: colon and semi-colon (":" and ";") characters.
 52 |      *
 53 |      * @return string[] the patterns
 54 |      */
 55 |     public function getTokenSeparators() : array
 56 |     {
 57 |         return [':', ';'];
 58 |     }
 59 | 
 60 |     /**
 61 |      * Returns true if the passed token is a semi-colon.
 62 |      */
 63 |     protected function isEndToken(string $token) : bool
 64 |     {
 65 |         return ($token === ';');
 66 |     }
 67 | 
 68 |     /**
 69 |      * Returns true if the passed token is a colon.
 70 |      */
 71 |     protected function isStartToken(string $token) : bool
 72 |     {
 73 |         return ($token === ':');
 74 |     }
 75 | 
 76 |     /**
 77 |      * Overridden to always call processParts even for an empty set of
 78 |      * addresses, since a group could be empty.
 79 |      *
 80 |      * @param Iterator $tokens
 81 |      * @return IHeaderPart[]
 82 |      */
 83 |     protected function parseTokensIntoParts(Iterator $tokens) : array
 84 |     {
 85 |         $ret = parent::parseTokensIntoParts($tokens);
 86 |         if ($ret === []) {
 87 |           return $this->processParts([]);
 88 |         }
 89 |         return $ret;
 90 |     }
 91 | 
 92 |     /**
 93 |      * Performs post-processing on parsed parts.
 94 |      *
 95 |      * Returns an array with a single
 96 |      * {@see AddressGroupPart} element with all email addresses from this and
 97 |      * any sub-groups.
 98 |      *
 99 |      * @param \ZBateson\MailMimeParser\Header\IHeaderPart[] $parts
100 |      * @return AddressGroupPart[]|array
101 |      */
102 |     protected function processParts(array $parts) : array
103 |     {
104 |         return [$this->partFactory->newAddressGroupPart([], $parts)];
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/src/Error.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser;
  9 | 
 10 | use InvalidArgumentException;
 11 | use Psr\Log\LogLevel;
 12 | use Throwable;
 13 | 
 14 | /**
 15 |  * Holds information about an error or notice that happened on a specific
 16 |  * object.
 17 |  *
 18 |  * @author Zaahid Bateson
 19 |  */
 20 | class Error
 21 | {
 22 |     /**
 23 |      * @var string The error message.
 24 |      */
 25 |     protected string $message;
 26 | 
 27 |     /**
 28 |      * @var string The PSR log level for this error.
 29 |      */
 30 |     protected string $psrLevel;
 31 | 
 32 |     /**
 33 |      * @var ErrorBag The object the error/notice occurred on.
 34 |      */
 35 |     protected ErrorBag $object;
 36 | 
 37 |     /**
 38 |      * @var ?Throwable An Exception object if one happened, or null if not
 39 |      */
 40 |     protected ?Throwable $exception;
 41 | 
 42 |     /**
 43 |      * @var array<string, int>
 44 |      */
 45 |     private array $levelMap = [
 46 |         LogLevel::EMERGENCY => 0,
 47 |         LogLevel::ALERT => 1,
 48 |         LogLevel::CRITICAL => 2,
 49 |         LogLevel::ERROR => 3,
 50 |         LogLevel::WARNING => 4,
 51 |         LogLevel::NOTICE => 5,
 52 |         LogLevel::INFO => 6,
 53 |         LogLevel::DEBUG => 7,
 54 |     ];
 55 | 
 56 |     /**
 57 |      *
 58 |      * @throws InvalidArgumentException if the passed $psrLogLevelAsErrorLevel
 59 |      *         is not a known PSR log level (see \Psr\Log\LogLevel)
 60 |      */
 61 |     public function __construct(string $message, string $psrLogLevelAsErrorLevel, ErrorBag $object, ?Throwable $exception = null)
 62 |     {
 63 |         if (!isset($this->levelMap[$psrLogLevelAsErrorLevel])) {
 64 |             throw new InvalidArgumentException($psrLogLevelAsErrorLevel . ' is not a known PSR Log Level');
 65 |         }
 66 |         $this->message = $message;
 67 |         $this->psrLevel = $psrLogLevelAsErrorLevel;
 68 |         $this->object = $object;
 69 |         $this->exception = $exception;
 70 |     }
 71 | 
 72 |     /**
 73 |      * Returns the error message.
 74 |      */
 75 |     public function getMessage() : string
 76 |     {
 77 |         return $this->message;
 78 |     }
 79 | 
 80 |     /**
 81 |      * Returns the PSR string log level for this error message.
 82 |      */
 83 |     public function getPsrLevel() : string
 84 |     {
 85 |         return $this->psrLevel;
 86 |     }
 87 | 
 88 |     /**
 89 |      * Returns the class type the error occurred on.
 90 |      */
 91 |     public function getClass() : string
 92 |     {
 93 |         return \get_class($this->object);
 94 |     }
 95 | 
 96 |     /**
 97 |      * Returns the object the error occurred on.
 98 |      */
 99 |     public function getObject() : ErrorBag
100 |     {
101 |         return $this->object;
102 |     }
103 | 
104 |     /**
105 |      * Returns the exception that occurred, if any, or null.
106 |      */
107 |     public function getException() : ?Throwable
108 |     {
109 |         return $this->exception;
110 |     }
111 | 
112 |     /**
113 |      * Returns true if the PSR log level for this error is equal to or greater
114 |      * than the one passed, e.g. passing LogLevel::ERROR would return true for
115 |      * LogLevel::ERROR and LogLevel::CRITICAL, ALERT and EMERGENCY.
116 |      */
117 |     public function isPsrLevelGreaterOrEqualTo(string $minLevel) : bool
118 |     {
119 |         $minIntLevel = $this->levelMap[$minLevel] ?? 1000;
120 |         $thisLevel = $this->levelMap[$this->psrLevel];
121 |         return ($minIntLevel >= $thisLevel);
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/Header/ParameterHeader.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MailMimeParser\Header\Consumer\IConsumerService;
 12 | use ZBateson\MailMimeParser\Header\Consumer\ParameterConsumerService;
 13 | use ZBateson\MailMimeParser\Header\Part\NameValuePart;
 14 | use ZBateson\MailMimeParser\MailMimeParser;
 15 | 
 16 | /**
 17 |  * Represents a header containing an optional main value part and subsequent
 18 |  * name/value pairs.
 19 |  *
 20 |  * If header doesn't contain a non-parameterized 'main' value part, 'getValue()'
 21 |  * will return the value of the first parameter.
 22 |  *
 23 |  * For example: 'Content-Type: text/html; charset=utf-8; name=test.ext'
 24 |  *
 25 |  * The 'text/html' portion is considered the 'main' value, and 'charset' and
 26 |  * 'name' are added as parameterized name/value pairs.
 27 |  *
 28 |  * With the Autocrypt header, there is no main value portion, for example:
 29 |  * 'Autocrypt: addr=zb@example.com; keydata=b64-data'
 30 |  *
 31 |  * In that example, calling ```php $header->getValue() ``` would return
 32 |  * 'zb@example.com', as would calling ```php $header->getValueFor('addr'); ```.
 33 |  *
 34 |  * @author Zaahid Bateson
 35 |  */
 36 | class ParameterHeader extends AbstractHeader
 37 | {
 38 |     /**
 39 |      * @var ParameterPart[] key map of lower-case parameter names and associated
 40 |      *      ParameterParts.
 41 |      */
 42 |     protected array $parameters = [];
 43 | 
 44 |     public function __construct(
 45 |         string $name,
 46 |         string $value,
 47 |         ?LoggerInterface $logger = null,
 48 |         ?ParameterConsumerService $consumerService = null
 49 |     ) {
 50 |         $di = MailMimeParser::getGlobalContainer();
 51 |         parent::__construct(
 52 |             $logger ?? $di->get(LoggerInterface::class),
 53 |             $consumerService ?? $di->get(ParameterConsumerService::class),
 54 |             $name,
 55 |             $value
 56 |         );
 57 |     }
 58 | 
 59 |     /**
 60 |      * Overridden to assign ParameterParts to a map of lower-case parameter
 61 |      * names to ParameterParts.
 62 |      */
 63 |     protected function parseHeaderValue(IConsumerService $consumer, string $value) : void
 64 |     {
 65 |         parent::parseHeaderValue($consumer, $value);
 66 |         foreach ($this->parts as $part) {
 67 |             if ($part instanceof NameValuePart) {
 68 |                 $this->parameters[\strtolower($part->getName())] = $part;
 69 |             }
 70 |         }
 71 |     }
 72 | 
 73 |     /**
 74 |      * Returns true if a parameter exists with the passed name.
 75 |      *
 76 |      * @param string $name The parameter to look up.
 77 |      */
 78 |     public function hasParameter(string $name) : bool
 79 |     {
 80 |         return isset($this->parameters[\strtolower($name)]);
 81 |     }
 82 | 
 83 |     /**
 84 |      * Returns the value of the parameter with the given name, or $defaultValue
 85 |      * if not set.
 86 |      *
 87 |      * @param string $name The parameter to retrieve.
 88 |      * @param string $defaultValue Optional default value (defaulting to null if
 89 |      *        not provided).
 90 |      * @return string|null The parameter's value.
 91 |      */
 92 |     public function getValueFor(string $name, ?string $defaultValue = null) : ?string
 93 |     {
 94 |         if (!$this->hasParameter($name)) {
 95 |             return $defaultValue;
 96 |         }
 97 |         return $this->parameters[\strtolower($name)]->getValue();
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/di_config.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | use DI\Definition\Helper\AutowireDefinitionHelper;
 9 | use DI\Definition\Reference;
10 | use Psr\Log\LoggerInterface;
11 | use Psr\Log\NullLogger;
12 | use ZBateson\MailMimeParser\Header\Consumer\Received\DomainConsumerService;
13 | use ZBateson\MailMimeParser\Header\Consumer\Received\GenericReceivedConsumerService;
14 | use ZBateson\MailMimeParser\Header\Consumer\ReceivedConsumerService;
15 | use ZBateson\MailMimeParser\Message\Factory\PartStreamContainerFactory;
16 | use ZBateson\MailMimeParser\Message\PartStreamContainer;
17 | use ZBateson\MailMimeParser\Parser\Part\ParserPartStreamContainerFactory;
18 | use ZBateson\MailMimeParser\Stream\StreamFactory;
19 | 
20 | return [
21 |     LoggerInterface::class => new AutowireDefinitionHelper(NullLogger::class),
22 | 
23 |     // only affects reading part content, not for instance decoding mime encoded
24 |     // header parts
25 |     'throwExceptionReadingPartContentFromUnsupportedCharsets' => false,
26 | 
27 |     'fromDomainConsumerService' => (new AutowireDefinitionHelper(DomainConsumerService::class))
28 |         ->constructorParameter('partName', 'from'),
29 |     'byDomainConsumerService' => (new AutowireDefinitionHelper(DomainConsumerService::class))
30 |         ->constructorParameter('partName', 'by'),
31 |     'viaGenericReceivedConsumerService' => (new AutowireDefinitionHelper(GenericReceivedConsumerService::class))
32 |         ->constructorParameter('partName', 'via'),
33 |     'withGenericReceivedConsumerService' => (new AutowireDefinitionHelper(GenericReceivedConsumerService::class))
34 |         ->constructorParameter('partName', 'with'),
35 |     'idGenericReceivedConsumerService' => (new AutowireDefinitionHelper(GenericReceivedConsumerService::class))
36 |         ->constructorParameter('partName', 'id'),
37 |     'forGenericReceivedConsumerService' => (new AutowireDefinitionHelper(GenericReceivedConsumerService::class))
38 |         ->constructorParameter('partName', 'for'),
39 |     ReceivedConsumerService::class => (new AutowireDefinitionHelper())
40 |         ->constructor(
41 |             fromDomainConsumerService: new Reference('fromDomainConsumerService'),
42 |             byDomainConsumerService: new Reference('byDomainConsumerService'),
43 |             viaGenericReceivedConsumerService: new Reference('viaGenericReceivedConsumerService'),
44 |             withGenericReceivedConsumerService: new Reference('withGenericReceivedConsumerService'),
45 |             idGenericReceivedConsumerService: new Reference('idGenericReceivedConsumerService'),
46 |             forGenericReceivedConsumerService: new Reference('forGenericReceivedConsumerService')
47 |         ),
48 |     PartStreamContainer::class => (new AutowireDefinitionHelper())
49 |         ->constructor(
50 |             throwExceptionReadingPartContentFromUnsupportedCharsets: new Reference('throwExceptionReadingPartContentFromUnsupportedCharsets')
51 |         ),
52 |     PartStreamContainerFactory::class => (new AutowireDefinitionHelper())
53 |         ->constructor(
54 |             throwExceptionReadingPartContentFromUnsupportedCharsets: new Reference('throwExceptionReadingPartContentFromUnsupportedCharsets')
55 |         ),
56 |     ParserPartStreamContainerFactory::class => (new AutowireDefinitionHelper())
57 |         ->constructor(
58 |             throwExceptionReadingPartContentFromUnsupportedCharsets: new Reference('throwExceptionReadingPartContentFromUnsupportedCharsets')
59 |         ),
60 |     StreamFactory::class => (new AutowireDefinitionHelper())
61 |         ->constructor(
62 |             throwExceptionReadingPartContentFromUnsupportedCharsets: new Reference('throwExceptionReadingPartContentFromUnsupportedCharsets')
63 |         ),
64 | ];
65 | 


--------------------------------------------------------------------------------
/src/Header/Part/SplitParameterPart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Part;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MbWrapper\MbWrapper;
 12 | 
 13 | /**
 14 |  * Holds a running value for an RFC-2231 split header parameter.
 15 |  *
 16 |  * ParameterConsumer creates SplitParameterTokens when a split header parameter
 17 |  * is first found, and adds subsequent split parts to an already created one if
 18 |  * the parameter name matches.
 19 |  *
 20 |  * @author Zaahid Bateson
 21 |  */
 22 | class SplitParameterPart extends ParameterPart
 23 | {
 24 |     /**
 25 |      * @var HeaderPartFactory used to create combined MimeToken parts.
 26 |      */
 27 |     protected HeaderPartFactory $partFactory;
 28 | 
 29 |     /**
 30 |      * Initializes a SplitParameterToken.
 31 |      *
 32 |      * @param ParameterPart[] $children
 33 |      */
 34 |     public function __construct(
 35 |         LoggerInterface $logger,
 36 |         MbWrapper $charsetConverter,
 37 |         HeaderPartFactory $headerPartFactory,
 38 |         array $children
 39 |     ) {
 40 |         $this->partFactory = $headerPartFactory;
 41 |         NameValuePart::__construct($logger, $charsetConverter, [$children[0]], $children);
 42 |         $this->children = $children;
 43 |     }
 44 | 
 45 |     protected function getNameFromParts(array $parts) : string
 46 |     {
 47 |         return $parts[0]->getName();
 48 |     }
 49 | 
 50 |     private function getMimeTokens(string $value) : array
 51 |     {
 52 |         $pattern = MimeToken::MIME_PART_PATTERN;
 53 |         // remove whitespace between two adjacent mime encoded parts
 54 |         $normed = \preg_replace("/($pattern)\\s+(?=$pattern)/", '$1', $value);
 55 |         // with PREG_SPLIT_DELIM_CAPTURE, matched and unmatched parts are returned
 56 |         $aMimeParts = \preg_split("/($pattern)/", $normed, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
 57 |         return \array_map(
 58 |             fn ($p) => (\preg_match("/$pattern/", $p)) ? $this->partFactory->newMimeToken($p) : $this->partFactory->newToken($p, true, true),
 59 |             $aMimeParts
 60 |         );
 61 |     }
 62 | 
 63 |     private function combineAdjacentUnencodedParts(array $parts) : array
 64 |     {
 65 |         $runningValue = '';
 66 |         $returnedParts = [];
 67 |         foreach ($parts as $part) {
 68 |             if (!$part->encoded) {
 69 |                 $runningValue .= $part->value;
 70 |                 continue;
 71 |             }
 72 |             if (!empty($runningValue)) {
 73 |                 $returnedParts = \array_merge($returnedParts, $this->getMimeTokens($runningValue));
 74 |                 $runningValue = '';
 75 |             }
 76 |             $returnedParts[] = $part;
 77 |         }
 78 |         if (!empty($runningValue)) {
 79 |             $returnedParts = \array_merge($returnedParts, $this->getMimeTokens($runningValue));
 80 |         }
 81 |         return $returnedParts;
 82 |     }
 83 | 
 84 |     protected function getValueFromParts(array $parts) : string
 85 |     {
 86 |         $sorted = $parts;
 87 |         \usort($sorted, fn ($a, $b) => $a->index <=> $b->index);
 88 | 
 89 |         $first = $sorted[0];
 90 |         $this->language = $first->language;
 91 |         $charset = $this->charset = $first->charset;
 92 | 
 93 |         $combined = $this->combineAdjacentUnencodedParts($sorted);
 94 | 
 95 |         return \implode('', \array_map(
 96 |             fn ($p) => ($p instanceof ParameterPart && $p->encoded)
 97 |                 ? $this->decodePartValue($p->getValue(), ($p->charset === null) ? $charset : $p->charset)
 98 |                 : $p->getValue(),
 99 |             $combined
100 |         ));
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/src/Parser/IParserService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Parser;
 9 | 
10 | use ZBateson\MailMimeParser\Parser\Proxy\ParserMimePartProxy;
11 | use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxy;
12 | use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxyFactory;
13 | 
14 | /**
15 |  * Interface defining a message part parser.
16 |  *
17 |  * @author Zaahid Bateson
18 |  */
19 | interface IParserService
20 | {
21 |     /**
22 |      * Sets up the passed ParserManager as the ParserManager for this part,
23 |      * which should be used when a new part is created (after its headers are
24 |      * read and a PartBuilder is created from it.)
25 |      *
26 |      * @param ParserManagerService $pm The ParserManager to set.
27 |      */
28 |     public function setParserManager(ParserManagerService $pm) : static;
29 | 
30 |     /**
31 |      * Called by the ParserManager to determine if the passed PartBuilder is a
32 |      * part handled by this IParser.
33 |      */
34 |     public function canParse(PartBuilder $part) : bool;
35 | 
36 |     /**
37 |      * Returns the ParserPartProxyFactory responsible for creating IMessage
38 |      * parts for this parser.
39 |      *
40 |      * This is called by ParserManager after 'canParse' if it returns true so
41 |      * a ParserPartProxy can be created out of the PartBuilder.
42 |      */
43 |     public function getParserMessageProxyFactory() : ParserPartProxyFactory;
44 | 
45 |     /**
46 |      * Returns the ParserPartProxyFactory responsible for creating IMessagePart
47 |      * parts for this parser.
48 |      *
49 |      * This is called by ParserManager after 'canParse' if it returns true so
50 |      * a ParserPartProxy can be created out of the PartBuilder.
51 |      */
52 |     public function getParserPartProxyFactory() : ParserPartProxyFactory;
53 | 
54 |     /**
55 |      * Performs read operations for content from the stream of the passed
56 |      * ParserPartProxy, and setting content bounds for the part in the passed
57 |      * ParserPartProxy.
58 |      *
59 |      * The implementation should call $proxy->setStreamContentStartPos() and
60 |      * $proxy->setStreamContentAndPartEndPos() so an IMessagePart can return
61 |      * content from the raw message.
62 |      *
63 |      * Reading should stop once the end of the current part's content has been
64 |      * reached or the end of the message has been reached.  If the end of the
65 |      * message has been reached $proxy->setEof() should be called in addition to
66 |      * setStreamContentAndPartEndPos().
67 |      */
68 |     public function parseContent(ParserPartProxy $proxy) : static;
69 | 
70 |     /**
71 |      * Performs read operations to read children from the passed $proxy, using
72 |      * its stream, and reading up to (and not including) the beginning of the
73 |      * child's content if another child exists.
74 |      *
75 |      * The implementation should:
76 |      *  1. Return null if there are no more children.
77 |      *  2. Read headers
78 |      *  3. Create a PartBuilder (adding the passed $proxy as its parent)
79 |      *  4. Call ParserManager::createParserProxyFor() on the ParserManager
80 |      *     previously set by a call to setParserManager(), which may determine
81 |      *     that a different parser is responsible for parts represented by
82 |      *     the headers and PartBuilder passed to it.
83 |      *
84 |      * The method should then return the ParserPartProxy returned by the
85 |      * ParserManager, or null if there are no more children to read.
86 |      *
87 |      * @return ParserPartProxy|null The child ParserPartProxy or null if there
88 |      *         are no more children under $proxy.
89 |      */
90 |     public function parseNextChild(ParserMimePartProxy $proxy) : ?ParserPartProxy;
91 | }
92 | 


--------------------------------------------------------------------------------
/src/Header/Part/MimeToken.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Part;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MbWrapper\MbWrapper;
 12 | 
 13 | /**
 14 |  * Represents a single mime header part token, with the possibility of it being
 15 |  * MIME-Encoded as per RFC-2047.
 16 |  *
 17 |  * MimeToken automatically decodes the value if it's encoded.
 18 |  *
 19 |  * @author Zaahid Bateson
 20 |  */
 21 | class MimeToken extends Token
 22 | {
 23 |     /**
 24 |      * @var string regex pattern matching a mime-encoded part
 25 |      */
 26 |     public const MIME_PART_PATTERN = '=\?[^?=]+\?[QBqb]\?[^\?]+\?=';
 27 | 
 28 |     /**
 29 |      * @var string regex pattern used when parsing parameterized headers
 30 |      */
 31 |     public const MIME_PART_PATTERN_NO_QUOTES = '=\?[^\?=]+\?[QBqb]\?[^\?"]+\?=';
 32 | 
 33 |     /**
 34 |      * @var ?string the language code if any, or null otherwise
 35 |      */
 36 |     protected ?string $language = null;
 37 | 
 38 |     /**
 39 |      * @var ?string the charset if any, or null otherwise
 40 |      */
 41 |     protected ?string $charset = null;
 42 | 
 43 |     public function __construct(LoggerInterface $logger, MbWrapper $charsetConverter, string $value)
 44 |     {
 45 |         parent::__construct($logger, $charsetConverter, $value);
 46 |         $this->value = $this->decodeMime(\preg_replace('/\r|\n/', '', $this->value));
 47 |         $pattern = self::MIME_PART_PATTERN;
 48 |         $this->canIgnoreSpacesBefore = (bool) \preg_match("/^\s*{$pattern}|\s+/", $this->rawValue);
 49 |         $this->canIgnoreSpacesAfter = (bool) \preg_match("/{$pattern}\s*|\s+\$/", $this->rawValue);
 50 |     }
 51 | 
 52 |     /**
 53 |      * Finds and replaces mime parts with their values.
 54 |      *
 55 |      * The method splits the token value into an array on mime-part-patterns,
 56 |      * either replacing a mime part with its value by calling iconv_mime_decode
 57 |      * or converts the encoding on the text part by calling convertEncoding.
 58 |      */
 59 |     protected function decodeMime(string $value) : string
 60 |     {
 61 |         if (\preg_match('/^=\?([A-Za-z\-_0-9]+)\*?([A-Za-z\-_0-9]+)?\?([QBqb])\?([^\?]*)\?=$/', $value, $matches)) {
 62 |             return $this->decodeMatchedEntity($matches);
 63 |         }
 64 |         return $this->convertEncoding($value);
 65 |     }
 66 | 
 67 |     /**
 68 |      * Decodes a matched mime entity part into a string and returns it, after
 69 |      * adding the string into the languages array.
 70 |      *
 71 |      * @param string[] $matches
 72 |      */
 73 |     private function decodeMatchedEntity(array $matches) : string
 74 |     {
 75 |         $body = $matches[4];
 76 |         if (\strtoupper($matches[3]) === 'Q') {
 77 |             $body = \quoted_printable_decode(\str_replace('_', '=20', $body));
 78 |         } else {
 79 |             $body = \base64_decode($body);
 80 |         }
 81 |         $this->charset = $matches[1];
 82 |         $this->language = (!empty($matches[2])) ? $matches[2] : null;
 83 |         if ($this->charset !== null) {
 84 |             return $this->convertEncoding($body, $this->charset, true);
 85 |         }
 86 |         return $this->convertEncoding($body, 'ISO-8859-1', true);
 87 |     }
 88 | 
 89 |     /**
 90 |      * Returns the language code for the mime part.
 91 |      */
 92 |     public function getLanguage() : ?string
 93 |     {
 94 |         return $this->language;
 95 |     }
 96 | 
 97 |     /**
 98 |      * Returns the charset for the encoded part.
 99 |      */
100 |     public function getCharset() : ?string
101 |     {
102 |         return $this->charset;
103 |     }
104 | 
105 |     public function getRawValue() : string
106 |     {
107 |         return $this->rawValue;
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/src/Header/Part/ReceivedDomainPart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Part;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MbWrapper\MbWrapper;
 12 | 
 13 | /**
 14 |  * Holds extra information about a parsed Received header part, for FROM and BY
 15 |  * parts, namely: ehlo name, hostname, and address.
 16 |  *
 17 |  * The parsed parts would be mapped as follows:
 18 |  *
 19 |  * FROM ehlo name (hostname [address]), for example: FROM computer (domain.com
 20 |  * [1.2.3.4]) would contain "computer" for getEhloName(), domain.com for
 21 |  * getHostname and 1.2.3.4 for getAddress().
 22 |  *
 23 |  * This doesn't change if the ehlo name is an address, it is still returned in
 24 |  * getEhloName(), and not in getAddress().  Additionally square brackets are not
 25 |  * stripped from getEhloName() if its an address.  For example: "FROM [1.2.3.4]"
 26 |  * would return "[1.2.3.4]" in a call to getEhloName().
 27 |  *
 28 |  * For further information on how the header's parsed, check the documentation
 29 |  * for {@see \ZBateson\MailMimeParser\Header\Consumer\Received\DomainConsumer}.
 30 |  *
 31 |  * @author Zaahid Bateson
 32 |  */
 33 | class ReceivedDomainPart extends ReceivedPart
 34 | {
 35 |     /**
 36 |      * @var string The name used to identify the server in the EHLO line.
 37 |      */
 38 |     protected ?string $ehloName = null;
 39 | 
 40 |     /**
 41 |      * @var string The hostname.
 42 |      */
 43 |     protected ?string $hostname = null;
 44 | 
 45 |     /**
 46 |      * @var string The address.
 47 |      */
 48 |     protected ?string $address = null;
 49 | 
 50 |     /**
 51 |      * @param HeaderPart[] $children
 52 |      */
 53 |     public function __construct(
 54 |         LoggerInterface $logger,
 55 |         MbWrapper $charsetConverter,
 56 |         string $name,
 57 |         array $children
 58 |     ) {
 59 |         parent::__construct($logger, $charsetConverter, $name, $children);
 60 | 
 61 |         $this->ehloName = ($this->value !== '') ? $this->value : null;
 62 |         $cps = $this->getComments();
 63 |         $commentPart = (!empty($cps)) ? $cps[0] : null;
 64 | 
 65 |         $pattern = '~^(\[(IPv[64])?(?P<addr1>[a-f\d\.\:]+)\])?\s*(helo=)?(?P<name>[a-z0-9\-]+[a-z0-9\-\.]+)?\s*(\[(IPv[64])?(?P<addr2>[a-f\d\.\:]+)\])?$~i';
 66 |         if ($commentPart !== null && \preg_match($pattern, $commentPart->getComment(), $matches)) {
 67 |             $this->value .= ' (' . $commentPart->getComment() . ')';
 68 |             $this->hostname = (!empty($matches['name'])) ? $matches['name'] : null;
 69 |             $this->address = (!empty($matches['addr1'])) ? $matches['addr1'] : ((!empty($matches['addr2'])) ? $matches['addr2'] : null);
 70 |         }
 71 |     }
 72 | 
 73 |     /**
 74 |      * Returns the name used to identify the server in the first part of the
 75 |      * extended-domain line.
 76 |      *
 77 |      * Note that this is not necessarily the name used in the EHLO line to an
 78 |      * SMTP server, since implementations differ so much, not much can be
 79 |      * guaranteed except the position it was parsed in.
 80 |      */
 81 |     public function getEhloName() : ?string
 82 |     {
 83 |         return $this->ehloName;
 84 |     }
 85 | 
 86 |     /**
 87 |      * Returns the hostname of the server, or whatever string in the hostname
 88 |      * position when parsing (but never an address).
 89 |      */
 90 |     public function getHostname() : ?string
 91 |     {
 92 |         return $this->hostname;
 93 |     }
 94 | 
 95 |     /**
 96 |      * Returns the address of the server, or whatever string that looks like an
 97 |      * address in the address position when parsing (but never a hostname).
 98 |      */
 99 |     public function getAddress() : ?string
100 |     {
101 |         return $this->address;
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/ParameterConsumerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * This file is part of the ZBateson\MailMimeParser project.
 4 |  *
 5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
 6 |  */
 7 | 
 8 | namespace ZBateson\MailMimeParser\Header\Consumer;
 9 | 
10 | use Iterator;
11 | use Psr\Log\LoggerInterface;
12 | use ZBateson\MailMimeParser\Header\IHeaderPart;
13 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
14 | use ZBateson\MailMimeParser\Header\Part\ParameterPart;
15 | 
16 | /**
17 |  * Reads headers separated into parameters consisting of an optional main value,
18 |  * and subsequent name/value pairs - for example text/html; charset=utf-8.
19 |  *
20 |  * A ParameterConsumerService's parts are separated by a semi-colon.  Its
21 |  * name/value pairs are separated with an '=' character.
22 |  *
23 |  * Parts may be mime-encoded entities, or RFC-2231 split/encoded parts.
24 |  * Additionally, a value can be quoted and comments may exist.
25 |  *
26 |  * Actual processing of parameters is done in ParameterNameValueConsumerService,
27 |  * with ParameterConsumerService processing all collected parts into split
28 |  * parameter parts as necessary.
29 |  *
30 |  * @author Zaahid Bateson
31 |  */
32 | class ParameterConsumerService extends AbstractGenericConsumerService
33 | {
34 |     use QuotedStringMimeLiteralPartTokenSplitPatternTrait;
35 | 
36 |     public function __construct(
37 |         LoggerInterface $logger,
38 |         HeaderPartFactory $partFactory,
39 |         ParameterNameValueConsumerService $parameterNameValueConsumerService,
40 |         CommentConsumerService $commentConsumerService,
41 |         QuotedStringConsumerService $quotedStringConsumerService
42 |     ) {
43 |         parent::__construct(
44 |             $logger,
45 |             $partFactory,
46 |             [$parameterNameValueConsumerService, $commentConsumerService, $quotedStringConsumerService]
47 |         );
48 |     }
49 | 
50 |     /**
51 |      * Disables advancing for start tokens.
52 |      */
53 |     protected function advanceToNextToken(Iterator $tokens, bool $isStartToken) : static
54 |     {
55 |         if ($isStartToken) {
56 |             return $this;
57 |         }
58 |         parent::advanceToNextToken($tokens, $isStartToken);
59 |         return $this;
60 |     }
61 | 
62 |     /**
63 |      * Post processing involves looking for split parameter parts with matching
64 |      * names and combining them into a SplitParameterPart, and otherwise
65 |      * returning ParameterParts from ParameterNameValueConsumer as-is.
66 |      *
67 |      * @param IHeaderPart[] $parts The parsed parts.
68 |      * @return IHeaderPart[] Array of resulting final parts.
69 |      */
70 |     protected function processParts(array $parts) : array
71 |     {
72 |         $factory = $this->partFactory;
73 |         return \array_values(\array_map(
74 |             function($partsArray) use ($factory) {
75 |                 if (\count($partsArray) > 1) {
76 |                     return $factory->newSplitParameterPart($partsArray);
77 |                 }
78 |                 return $partsArray[0];
79 |             },
80 |             \array_merge_recursive(...\array_map(
81 |                 function($p) {
82 |                     // if $p->getIndex is non-null, it's a split-parameter part
83 |                     // and an array of one element consisting of name => ParameterPart
84 |                     // is returned, which is then merged into name => array-of-parameter-parts
85 |                     // or ';' object_id . ';' for non-split parts with a value of a single
86 |                     // element array of [ParameterPart]
87 |                     if ($p instanceof ParameterPart && $p->getIndex() !== null) {
88 |                         return [\strtolower($p->getName()) => [$p]];
89 |                     }
90 |                     return [';' . \spl_object_id($p) . ';' => [$p]];
91 |                 },
92 |                 $parts
93 |             ))
94 |         ));
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/Header/Part/HeaderPart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Part;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use Psr\Log\LogLevel;
 12 | use ZBateson\MailMimeParser\ErrorBag;
 13 | use ZBateson\MailMimeParser\Header\IHeaderPart;
 14 | use ZBateson\MbWrapper\MbWrapper;
 15 | use ZBateson\MbWrapper\UnsupportedCharsetException;
 16 | 
 17 | /**
 18 |  * Abstract base class representing a single part of a parsed header.
 19 |  *
 20 |  * @author Zaahid Bateson
 21 |  */
 22 | abstract class HeaderPart extends ErrorBag implements IHeaderPart
 23 | {
 24 |     /**
 25 |      * @var string the representative value of the part after any conversion or
 26 |      *      processing has been done on it (e.g. removing new lines, converting,
 27 |      *      whatever else).
 28 |      */
 29 |     protected string $value;
 30 | 
 31 |     /**
 32 |      * @var MbWrapper $charsetConverter the charset converter used for
 33 |      *      converting strings in HeaderPart::convertEncoding
 34 |      */
 35 |     protected MbWrapper $charsetConverter;
 36 | 
 37 |     /**
 38 |      * @var bool set to true to ignore spaces before this part
 39 |      */
 40 |     protected bool $canIgnoreSpacesBefore = false;
 41 | 
 42 |     /**
 43 |      * @var bool set to true to ignore spaces after this part
 44 |      */
 45 |     protected bool $canIgnoreSpacesAfter = false;
 46 | 
 47 |     /**
 48 |      * True if the part is a space token
 49 |      */
 50 |     protected bool $isSpace = false;
 51 | 
 52 |     public function __construct(LoggerInterface $logger, MbWrapper $charsetConverter, string $value)
 53 |     {
 54 |         parent::__construct($logger);
 55 |         $this->charsetConverter = $charsetConverter;
 56 |         $this->value = $value;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Returns the part's representative value after any necessary processing
 61 |      * has been performed.  For the raw value, call getRawValue().
 62 |      */
 63 |     public function getValue() : string
 64 |     {
 65 |         return $this->value;
 66 |     }
 67 | 
 68 |     /**
 69 |      * Returns the value of the part (which is a string).
 70 |      *
 71 |      * @return string the value
 72 |      */
 73 |     public function __toString() : string
 74 |     {
 75 |         return $this->value;
 76 |     }
 77 | 
 78 |     /**
 79 |      * Ensures the encoding of the passed string is set to UTF-8.
 80 |      *
 81 |      * The method does nothing if the passed $from charset is UTF-8 already, or
 82 |      * if $force is set to false and mb_check_encoding for $str returns true
 83 |      * for 'UTF-8'.
 84 |      *
 85 |      * @return string utf-8 string
 86 |      */
 87 |     protected function convertEncoding(string $str, string $from = 'ISO-8859-1', bool $force = false) : string
 88 |     {
 89 |         if ($from !== 'UTF-8') {
 90 |             // mime header part decoding will force it.  This is necessary for
 91 |             // UTF-7 because mb_check_encoding will return true
 92 |             if ($force || !($this->charsetConverter->checkEncoding($str, 'UTF-8'))) {
 93 |                 try {
 94 |                     return $this->charsetConverter->convert($str, $from, 'UTF-8');
 95 |                 } catch (UnsupportedCharsetException $ce) {
 96 |                     $this->addError('Unable to convert charset', LogLevel::ERROR, $ce);
 97 |                     return $this->charsetConverter->convert($str, 'ISO-8859-1', 'UTF-8');
 98 |                 }
 99 |             }
100 |         }
101 |         return $str;
102 |     }
103 | 
104 |     public function getComments() : array
105 |     {
106 |         return [];
107 |     }
108 | 
109 |     /**
110 |      * Default implementation returns an empty array.
111 |      */
112 |     protected function getErrorBagChildren() : array
113 |     {
114 |         return [];
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/CommentConsumerService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Consumer;
  9 | 
 10 | use Iterator;
 11 | use Psr\Log\LoggerInterface;
 12 | use ZBateson\MailMimeParser\Header\IHeaderPart;
 13 | use ZBateson\MailMimeParser\Header\Part\MimeTokenPartFactory;
 14 | 
 15 | /**
 16 |  * Consumes all tokens within parentheses as comments.
 17 |  *
 18 |  * Parenthetical comments in mime-headers can be nested within one another.  The
 19 |  * outer-level continues after an inner-comment ends.  Additionally,
 20 |  * quoted-literals may exist with comments as well meaning a parenthesis inside
 21 |  * a quoted string would not begin or end a comment section.
 22 |  *
 23 |  * In order to satisfy these specifications, CommentConsumerService inherits
 24 |  * from GenericConsumerService which defines CommentConsumerService and
 25 |  * QuotedStringConsumerService as sub-consumers.
 26 |  *
 27 |  * Examples:
 28 |  * X-Mime-Header: Some value (comment)
 29 |  * X-Mime-Header: Some value (comment (nested comment) still in comment)
 30 |  * X-Mime-Header: Some value (comment "and part of original ) comment" -
 31 |  *      still a comment)
 32 |  *
 33 |  * @author Zaahid Bateson
 34 |  */
 35 | class CommentConsumerService extends GenericConsumerService
 36 | {
 37 |     public function __construct(
 38 |         LoggerInterface $logger,
 39 |         MimeTokenPartFactory $partFactory,
 40 |         QuotedStringConsumerService $quotedStringConsumerService
 41 |     ) {
 42 |         parent::__construct(
 43 |             $logger,
 44 |             $partFactory,
 45 |             $this,
 46 |             $quotedStringConsumerService
 47 |         );
 48 |     }
 49 | 
 50 |     /**
 51 |      * Returns patterns matching open and close parenthesis characters
 52 |      * as separators.
 53 |      *
 54 |      * @return string[] the patterns
 55 |      */
 56 |     protected function getTokenSeparators() : array
 57 |     {
 58 |         return \array_merge(parent::getTokenSeparators(), ['\(', '\)']);
 59 |     }
 60 | 
 61 |     /**
 62 |      * Returns true if the token is an open parenthesis character, '('.
 63 |      */
 64 |     protected function isStartToken(string $token) : bool
 65 |     {
 66 |         return ($token === '(');
 67 |     }
 68 | 
 69 |     /**
 70 |      * Returns true if the token is a close parenthesis character, ')'.
 71 |      */
 72 |     protected function isEndToken(string $token) : bool
 73 |     {
 74 |         return ($token === ')');
 75 |     }
 76 | 
 77 |     /**
 78 |      * Instantiates and returns Part\Token objects.
 79 |      *
 80 |      * Tokens from this and sub-consumers are combined into a Part\CommentPart
 81 |      * in processParts.
 82 |      */
 83 |     protected function getPartForToken(string $token, bool $isLiteral) : ?IHeaderPart
 84 |     {
 85 |         return $this->partFactory->newInstance($token);
 86 |     }
 87 | 
 88 |     /**
 89 |      * Calls $tokens->next() and returns.
 90 |      *
 91 |      * The default implementation checks if the current token is an end token,
 92 |      * and will not advance past it.  Because a comment part of a header can be
 93 |      * nested, its implementation must advance past its own 'end' token.
 94 |      */
 95 |     protected function advanceToNextToken(Iterator $tokens, bool $isStartToken) : static
 96 |     {
 97 |         $tokens->next();
 98 |         return $this;
 99 |     }
100 | 
101 |     /**
102 |      * Post processing involves creating a single Part\CommentPart out of
103 |      * generated parts from tokens.  The Part\CommentPart is returned in an
104 |      * array.
105 |      *
106 |      * @param IHeaderPart[] $parts
107 |      * @return IHeaderPart[]
108 |      */
109 |     protected function processParts(array $parts) : array
110 |     {
111 |         return [$this->partFactory->newCommentPart($parts)];
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/src/ErrorBag.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use Psr\Log\LogLevel;
 12 | use Throwable;
 13 | 
 14 | /**
 15 |  * Provides a top-level abstract implementation of IErrorBag.
 16 |  *
 17 |  * @author Zaahid Bateson
 18 |  */
 19 | abstract class ErrorBag implements IErrorBag
 20 | {
 21 |     protected LoggerInterface $logger;
 22 | 
 23 |     /**
 24 |      * @var Error[] array of Error objects belonging to this object.
 25 |      */
 26 |     private array $errors = [];
 27 | 
 28 |     /**
 29 |      * @var bool true once the object has been validated.
 30 |      */
 31 |     private bool $validated = false;
 32 | 
 33 |     public function __construct(LoggerInterface $logger)
 34 |     {
 35 |         $this->logger = $logger;
 36 |     }
 37 | 
 38 |     /**
 39 |      * Returns the class name.  Override to identify objects in logs.
 40 |      *
 41 |      */
 42 |     public function getErrorLoggingContextName() : string
 43 |     {
 44 |         return static::class;
 45 |     }
 46 | 
 47 |     /**
 48 |      * Return any children ErrorBag objects.
 49 |      *
 50 |      * @return IErrorBag[]
 51 |      */
 52 |     abstract protected function getErrorBagChildren() : array;
 53 | 
 54 |     /**
 55 |      * Perform any extra validation and call 'addError'.
 56 |      *
 57 |      * getErrors and getAllErrors call validate() if their $validate parameter
 58 |      * is true.  validate() is only called once on an object with getErrors
 59 |      * getAllErrors.
 60 |      */
 61 |     protected function validate() : void
 62 |     {
 63 |         // do nothing
 64 |     }
 65 | 
 66 |     public function addError(string $message, string $psrLogLevel, ?Throwable $exception = null) : static
 67 |     {
 68 |         $error = new Error($message, $psrLogLevel, $this, $exception);
 69 |         $this->errors[] = $error;
 70 |         $this->logger->log(
 71 |             $psrLogLevel,
 72 |             '{contextName} {message} {exception}',
 73 |             [
 74 |                 'contextName' => $this->getErrorLoggingContextName(),
 75 |                 'message' => $message,
 76 |                 'exception' => $exception ?? ''
 77 |             ]
 78 |         );
 79 |         return $this;
 80 |     }
 81 | 
 82 |     public function getErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : array
 83 |     {
 84 |         if ($validate && !$this->validated) {
 85 |             $this->validated = true;
 86 |             $this->validate();
 87 |         }
 88 |         return \array_values(\array_filter(
 89 |             $this->errors,
 90 |             function($e) use ($minPsrLevel) {
 91 |                 return $e->isPsrLevelGreaterOrEqualTo($minPsrLevel);
 92 |             }
 93 |         ));
 94 |     }
 95 | 
 96 |     public function hasErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : bool
 97 |     {
 98 |         return (\count($this->getErrors($validate, $minPsrLevel)) > 0);
 99 |     }
100 | 
101 |     public function getAllErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : array
102 |     {
103 |         $arr = \array_values(\array_map(
104 |             function($e) use ($validate, $minPsrLevel) {
105 |                 return $e->getAllErrors($validate, $minPsrLevel);
106 |             },
107 |             $this->getErrorBagChildren()
108 |         ));
109 |         return \array_merge($this->getErrors($validate, $minPsrLevel), ...$arr);
110 |     }
111 | 
112 |     public function hasAnyErrors(bool $validate = false, string $minPsrLevel = LogLevel::ERROR) : bool
113 |     {
114 |         if ($this->hasErrors($validate, $minPsrLevel)) {
115 |             return true;
116 |         }
117 |         foreach ($this->getErrorBagChildren() as $ch) {
118 |             if ($ch->hasAnyErrors($validate, $minPsrLevel)) {
119 |                 return true;
120 |             }
121 |         }
122 |         return false;
123 |     }
124 | }
125 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/Received/GenericReceivedConsumerService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Consumer\Received;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MailMimeParser\Header\Consumer\AbstractGenericConsumerService;
 12 | use ZBateson\MailMimeParser\Header\Consumer\CommentConsumerService;
 13 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
 14 | 
 15 | /**
 16 |  * Consumes simple literal strings for parts of a Received header.
 17 |  *
 18 |  * Starts consuming when the initialized $partName string is located, for
 19 |  * instance when initialized with "FROM", will start consuming on " FROM" or
 20 |  * "FROM ".
 21 |  *
 22 |  * The consumer ends when any possible "Received" header part is found, namely
 23 |  * on one of the following tokens: from, by, via, with, id, for, or when the
 24 |  * start token for the date stamp is found, ';'.
 25 |  *
 26 |  * The consumer allows comments in and around the consumer... although the
 27 |  * Received header specification only allows them before a part, for example,
 28 |  * technically speaking this is valid:
 29 |  *
 30 |  * "FROM machine (host) (comment) BY machine"
 31 |  *
 32 |  * However, this is not:
 33 |  *
 34 |  * "FROM machine (host) BY machine WITH (comment) ESMTP"
 35 |  *
 36 |  * The consumer will allow both.
 37 |  *
 38 |  * @author Zaahid Bateson
 39 |  */
 40 | class GenericReceivedConsumerService extends AbstractGenericConsumerService
 41 | {
 42 |     /**
 43 |      * @var string the current part name being parsed.
 44 |      *
 45 |      * This is always the lower-case name provided to the constructor, not the
 46 |      * actual string that started the consumer, which could be in any case.
 47 |      */
 48 |     protected $partName;
 49 | 
 50 |     /**
 51 |      * Constructor overridden to include $partName parameter.
 52 |      *
 53 |      */
 54 |     public function __construct(
 55 |         LoggerInterface $logger,
 56 |         HeaderPartFactory $partFactory,
 57 |         CommentConsumerService $commentConsumerService,
 58 |         string $partName
 59 |     ) {
 60 |         parent::__construct($logger, $partFactory, [$commentConsumerService]);
 61 |         $this->partName = $partName;
 62 |     }
 63 | 
 64 |     /**
 65 |      * Returns true if the passed token matches (case-insensitively)
 66 |      * $this->getPartName() with optional whitespace surrounding it.
 67 |      */
 68 |     protected function isStartToken(string $token) : bool
 69 |     {
 70 |         $pattern = '/^' . \preg_quote($this->partName, '/') . '$/i';
 71 |         return (\preg_match($pattern, $token) === 1);
 72 |     }
 73 | 
 74 |     /**
 75 |      * Returns true if the token matches (case-insensitively) any of the
 76 |      * following, with optional surrounding whitespace:
 77 |      *
 78 |      * o by
 79 |      * o via
 80 |      * o with
 81 |      * o id
 82 |      * o for
 83 |      * o ;
 84 |      */
 85 |     protected function isEndToken(string $token) : bool
 86 |     {
 87 |         return (\preg_match('/^(by|via|with|id|for|;)$/i', $token) === 1);
 88 |     }
 89 | 
 90 |     /**
 91 |      * Returns a whitespace separator (for filtering ignorable whitespace
 92 |      * between parts), and a separator matching the current part name as
 93 |      * set on $this->partName.
 94 |      *
 95 |      * @return string[] an array of regex pattern matchers
 96 |      */
 97 |     protected function getTokenSeparators() : array
 98 |     {
 99 |         return [
100 |             '\s+',
101 |             '(\A\s*|\s+)(?i)' . \preg_quote($this->partName, '/') . '(?-i)(?=\s+)'
102 |         ];
103 |     }
104 | 
105 |     /**
106 |      * @param \ZBateson\MailMimeParser\Header\IHeaderPart[] $parts
107 |      * @return \ZBateson\MailMimeParser\Header\IHeaderPart[]
108 |      */
109 |     protected function processParts(array $parts) : array
110 |     {
111 |         return [$this->partFactory->newReceivedPart($this->partName, $parts)];
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/src/Header/Part/ParameterPart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Part;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MbWrapper\MbWrapper;
 12 | 
 13 | /**
 14 |  * Represents a name/value parameter part of a header.
 15 |  *
 16 |  * @author Zaahid Bateson
 17 |  */
 18 | class ParameterPart extends NameValuePart
 19 | {
 20 |     /**
 21 |      * @var string the RFC-1766 language tag if set.
 22 |      */
 23 |     protected ?string $language = null;
 24 | 
 25 |     /**
 26 |      * @var string charset of content if set.
 27 |      */
 28 |     protected ?string $charset = null;
 29 | 
 30 |     /**
 31 |      * @var int the zero-based index of the part if part of a 'continuation' in
 32 |      *      an RFC-2231 split parameter.
 33 |      */
 34 |     protected ?int $index = null;
 35 | 
 36 |     /**
 37 |      * @var bool true if the part is an RFC-2231 encoded part, and the value
 38 |      *      needs to be decoded.
 39 |      */
 40 |     protected bool $encoded = false;
 41 | 
 42 |     /**
 43 |      * @param HeaderPart[] $nameParts
 44 |      */
 45 |     public function __construct(
 46 |         LoggerInterface $logger,
 47 |         MbWrapper $charsetConverter,
 48 |         array $nameParts,
 49 |         ContainerPart $valuePart
 50 |     ) {
 51 |         parent::__construct($logger, $charsetConverter, $nameParts, $valuePart->children);
 52 |     }
 53 | 
 54 |     protected function getNameFromParts(array $parts) : string
 55 |     {
 56 |         $name = parent::getNameFromParts($parts);
 57 |         if (\preg_match('~^\s*([^\*]+)\*(\d*)(\*)?$~', $name, $matches)) {
 58 |             $name = $matches[1];
 59 |             $this->index = ($matches[2] !== '') ? (int) ($matches[2]) : null;
 60 |             $this->encoded = (($matches[2] === '') || !empty($matches[3]));
 61 |         }
 62 |         return $name;
 63 |     }
 64 | 
 65 |     protected function decodePartValue(string $value, ?string $charset = null) : string
 66 |     {
 67 |         if ($charset !== null) {
 68 |             return $this->convertEncoding(\rawurldecode($value), $charset, true);
 69 |         }
 70 |         return $this->convertEncoding(\rawurldecode($value));
 71 |     }
 72 | 
 73 |     protected function getValueFromParts(array $parts) : string
 74 |     {
 75 |         $value = parent::getValueFromParts($parts);
 76 |         if ($this->encoded && \preg_match('~^([^\']*)\'?([^\']*)\'?(.*)$~', $value, $matches)) {
 77 |             $this->charset = (!empty($matches[1]) && !empty($matches[3])) ? $matches[1] : $this->charset;
 78 |             $this->language = (!empty($matches[2])) ? $matches[2] : $this->language;
 79 |             $ev = (empty($matches[3])) ? $matches[1] : $matches[3];
 80 |             // only if it's not part of a SplitParameterPart
 81 |             if ($this->index === null) {
 82 |                 // subsequent parts are decoded as a SplitParameterPart since only
 83 |                 // the first part are supposed to have charset/language fields
 84 |                 return $this->decodePartValue($ev, $this->charset);
 85 |             }
 86 |             return $ev;
 87 |         }
 88 |         return $value;
 89 |     }
 90 | 
 91 |     /**
 92 |      * Returns the charset if the part is an RFC-2231 part with a charset set.
 93 |      */
 94 |     public function getCharset() : ?string
 95 |     {
 96 |         return $this->charset;
 97 |     }
 98 | 
 99 |     /**
100 |      * Returns the RFC-1766 (or subset) language tag, if the parameter is an
101 |      * RFC-2231 part with a language tag set.
102 |      *
103 |      * @return ?string the language if set, or null if not
104 |      */
105 |     public function getLanguage() : ?string
106 |     {
107 |         return $this->language;
108 |     }
109 | 
110 |     public function isUrlEncoded() : bool
111 |     {
112 |         return $this->encoded;
113 |     }
114 | 
115 |     public function getIndex() : ?int
116 |     {
117 |         return $this->index;
118 |     }
119 | }
120 | 


--------------------------------------------------------------------------------
/src/Header/Part/ContainerPart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Part;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MailMimeParser\ErrorBag;
 12 | use ZBateson\MbWrapper\MbWrapper;
 13 | 
 14 | /**
 15 |  * Base HeaderPart for a part that consists of other parts.
 16 |  *
 17 |  * The base container part constructs a string value out of the passed parts by
 18 |  * concatenating their values, discarding whitespace between parts that can be
 19 |  * ignored (in general allows for a single space but removes extras.)
 20 |  *
 21 |  * A ContainerPart can also contain any number of child comment parts.  The
 22 |  * CommentParts in this and all child parts can be returned by calling
 23 |  * getComments.
 24 |  *
 25 |  * @author Zaahid Bateson
 26 |  */
 27 | class ContainerPart extends HeaderPart
 28 | {
 29 |     /**
 30 |      * @var HeaderPart[] parts that were used to create this part, collected for
 31 |      *      proper error reporting and validation.
 32 |      */
 33 |     protected $children = [];
 34 | 
 35 |     public function __construct(
 36 |         LoggerInterface $logger,
 37 |         MbWrapper $charsetConverter,
 38 |         array $children
 39 |     ) {
 40 |         ErrorBag::__construct($logger);
 41 |         $this->charsetConverter = $charsetConverter;
 42 |         $this->children = $children;
 43 |         $str = (!empty($children)) ? $this->getValueFromParts($children) : '';
 44 |         parent::__construct(
 45 |             $logger,
 46 |             $this->charsetConverter,
 47 |             $str
 48 |         );
 49 |     }
 50 | 
 51 |     /**
 52 |      * Filters out ignorable space tokens.
 53 |      *
 54 |      * Spaces are removed if parts on either side of it have their
 55 |      * canIgnoreSpaceAfter/canIgnoreSpaceBefore properties set to true.
 56 |      *
 57 |      * @param HeaderPart[] $parts
 58 |      * @return HeaderPart[]
 59 |      */
 60 |     protected function filterIgnoredSpaces(array $parts) : array
 61 |     {
 62 |         $ends = (object) ['isSpace' => true, 'canIgnoreSpacesAfter' => true, 'canIgnoreSpacesBefore' => true, 'value' => ''];
 63 | 
 64 |         $spaced = \array_merge($parts, [$ends]);
 65 |         $filtered = \array_slice(\array_reduce(
 66 |             \array_slice(\array_keys($spaced), 0, -1),
 67 |             function($carry, $key) use ($spaced, $ends) {
 68 |                 $p = $spaced[$key];
 69 |                 $l = \end($carry);
 70 |                 $a = $spaced[$key + 1];
 71 |                 if ($p->isSpace && $a === $ends) {
 72 |                     // trim
 73 |                     if ($l->isSpace) {
 74 |                         \array_pop($carry);
 75 |                     }
 76 |                     return $carry;
 77 |                 } elseif ($p->isSpace && ($l->isSpace || ($l->canIgnoreSpacesAfter && $a->canIgnoreSpacesBefore))) {
 78 |                     return $carry;
 79 |                 }
 80 |                 return \array_merge($carry, [$p]);
 81 |             },
 82 |             [$ends]
 83 |         ), 1);
 84 |         return $filtered;
 85 |     }
 86 | 
 87 |     /**
 88 |      * Creates the string value representation of this part constructed from the
 89 |      * child parts passed to it.
 90 |      *
 91 |      * The default implementation filters out ignorable whitespace between
 92 |      * parts, and concatenates parts calling 'getValue'.
 93 |      *
 94 |      * @param HeaderParts[] $parts
 95 |      */
 96 |     protected function getValueFromParts(array $parts) : string
 97 |     {
 98 |         return \array_reduce($this->filterIgnoredSpaces($parts), fn ($c, $p) => $c . $p->getValue(), '');
 99 |     }
100 | 
101 |     /**
102 |      * Returns the child parts this container part consists of.
103 |      *
104 |      * @return IHeaderPart[]
105 |      */
106 |     public function getChildParts() : array
107 |     {
108 |         return $this->children;
109 |     }
110 | 
111 |     public function getComments() : array
112 |     {
113 |         return \array_merge(...\array_filter(\array_map(
114 |             fn ($p) => ($p instanceof CommentPart) ? [$p] : $p->getComments(),
115 |             $this->children
116 |         )));
117 |     }
118 | 
119 |     /**
120 |      * Returns this part's children, same as getChildParts().
121 |      *
122 |      * @return ErrorBag
123 |      */
124 |     protected function getErrorBagChildren() : array
125 |     {
126 |         return $this->children;
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/Header/AddressHeader.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header;
  9 | 
 10 | use Psr\Log\LoggerInterface;
 11 | use ZBateson\MailMimeParser\Header\Consumer\AddressBaseConsumerService;
 12 | use ZBateson\MailMimeParser\Header\Part\AddressGroupPart;
 13 | use ZBateson\MailMimeParser\Header\Part\AddressPart;
 14 | use ZBateson\MailMimeParser\MailMimeParser;
 15 | 
 16 | /**
 17 |  * A header containing one or more email addresses and/or groups of addresses.
 18 |  *
 19 |  * An address is separated by a comma, and each group separated by a semi-colon.
 20 |  * The AddressHeader provides a complete list of all addresses referenced in a
 21 |  * header including any addresses in groups, in addition to being able to access
 22 |  * the groups separately if needed.
 23 |  *
 24 |  * For full specifications, see {@link https://www.ietf.org/rfc/rfc2822.txt}
 25 |  *
 26 |  * @author Zaahid Bateson
 27 |  */
 28 | class AddressHeader extends AbstractHeader
 29 | {
 30 |     /**
 31 |      * @var AddressPart[] array of addresses, included all addresses contained
 32 |      *      in groups.
 33 |      */
 34 |     protected array $addresses = [];
 35 | 
 36 |     /**
 37 |      * @var AddressGroupPart[] array of address groups (lists).
 38 |      */
 39 |     protected array $groups = [];
 40 | 
 41 |     public function __construct(
 42 |         string $name,
 43 |         string $value,
 44 |         ?LoggerInterface $logger = null,
 45 |         ?AddressBaseConsumerService $consumerService = null
 46 |     ) {
 47 |         $di = MailMimeParser::getGlobalContainer();
 48 |         parent::__construct(
 49 |             $logger ?? $di->get(LoggerInterface::class),
 50 |             $consumerService ?? $di->get(AddressBaseConsumerService::class),
 51 |             $name,
 52 |             $value
 53 |         );
 54 |     }
 55 | 
 56 |     /**
 57 |      * Filters $this->allParts into the parts required by $this->parts
 58 |      * and assignes it.
 59 |      *
 60 |      * The AbstractHeader::filterAndAssignToParts method filters out CommentParts.
 61 |      */
 62 |     protected function filterAndAssignToParts() : void
 63 |     {
 64 |         parent::filterAndAssignToParts();
 65 |         foreach ($this->parts as $part) {
 66 |             if ($part instanceof AddressPart) {
 67 |                 $this->addresses[] = $part;
 68 |             } elseif ($part instanceof AddressGroupPart) {
 69 |                 $this->addresses = \array_merge($this->addresses, $part->getAddresses());
 70 |                 $this->groups[] = $part;
 71 |             }
 72 |         }
 73 |     }
 74 | 
 75 |     /**
 76 |      * Returns all address parts in the header including any addresses that are
 77 |      * in groups (lists).
 78 |      *
 79 |      * @return AddressPart[] The addresses.
 80 |      */
 81 |     public function getAddresses() : array
 82 |     {
 83 |         return $this->addresses;
 84 |     }
 85 | 
 86 |     /**
 87 |      * Returns all group parts (lists) in the header.
 88 |      *
 89 |      * @return AddressGroupPart[]
 90 |      */
 91 |     public function getGroups() : array
 92 |     {
 93 |         return $this->groups;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Returns true if an address exists with the passed email address.
 98 |      *
 99 |      * Comparison is done case insensitively.
100 |      *
101 |      */
102 |     public function hasAddress(string $email) : bool
103 |     {
104 |         foreach ($this->addresses as $addr) {
105 |             if (\strcasecmp($addr->getEmail(), $email) === 0) {
106 |                 return true;
107 |             }
108 |         }
109 |         return false;
110 |     }
111 | 
112 |     /**
113 |      * Returns the first email address in the header.
114 |      *
115 |      * @return ?string The email address
116 |      */
117 |     public function getEmail() : ?string
118 |     {
119 |         if (!empty($this->addresses)) {
120 |             return $this->addresses[0]->getEmail();
121 |         }
122 |         return null;
123 |     }
124 | 
125 |     /**
126 |      * Returns the name associated with the first email address to complement
127 |      * getEmail() if one is set, or null if not.
128 |      *
129 |      * @return string|null The person name.
130 |      */
131 |     public function getPersonName() : ?string
132 |     {
133 |         if (!empty($this->addresses)) {
134 |             return $this->addresses[0]->getName();
135 |         }
136 |         return null;
137 |     }
138 | }
139 | 


--------------------------------------------------------------------------------
/src/Parser/Proxy/ParserUUEncodedPartProxy.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Parser\Proxy;
  9 | 
 10 | /**
 11 |  * A bi-directional parser-to-part proxy for NonMimeParser and IUUEncodedParts.
 12 |  *
 13 |  * @author Zaahid Bateson
 14 |  */
 15 | class ParserUUEncodedPartProxy extends ParserPartProxy
 16 | {
 17 |     /**
 18 |      * Only has a single parent of type ParserNonMimeMessageProxy, overridden to
 19 |      * specify ParserNonMimeMessageProxy as the return type.
 20 |      */
 21 |     public function getParent() : ParserNonMimeMessageProxy
 22 |     {
 23 |         return parent::getParent();
 24 |     }
 25 | 
 26 |     /**
 27 |      * Returns the next part's start position within the message's raw stream,
 28 |      * or null if not set, not discovered, or there are no more parts under this
 29 |      * message.
 30 |      *
 31 |      * As this is a message-wide setting, ParserUUEncodedPartProxy calls
 32 |      * getNextPartStart() on its parent (a ParserNonMimeMessageProxy, which
 33 |      * stores/returns this information).
 34 |      *
 35 |      * @return int|null The start position or null
 36 |      */
 37 |     public function getNextPartStart() : ?int
 38 |     {
 39 |         return $this->getParent()->getNextPartStart();
 40 |     }
 41 | 
 42 |     /**
 43 |      * Returns the next part's unix file mode in a uu-encoded 'begin' line if
 44 |      * one exists, or null otherwise.
 45 |      *
 46 |      * As this is a message-wide setting, ParserUUEncodedPartProxy calls
 47 |      * getNextPartMode() on its parent (a ParserNonMimeMessageProxy, which
 48 |      * stores/returns this information).
 49 |      *
 50 |      * @return int|null The file mode or null
 51 |      */
 52 |     public function getNextPartMode() : ?int
 53 |     {
 54 |         return $this->getParent()->getNextPartMode();
 55 |     }
 56 | 
 57 |     /**
 58 |      * Returns the next part's filename in a uu-encoded 'begin' line if one
 59 |      * exists, or null otherwise.
 60 |      *
 61 |      * As this is a message-wide setting, ParserUUEncodedPartProxy calls
 62 |      * getNextPartFilename() on its parent (a ParserNonMimeMessageProxy, which
 63 |      * stores/returns this information).
 64 |      *
 65 |      * @return ?string The file name or null
 66 |      */
 67 |     public function getNextPartFilename() : ?string
 68 |     {
 69 |         return $this->getParent()->getNextPartFilename();
 70 |     }
 71 | 
 72 |     /**
 73 |      * Sets the next part's start position within the message's raw stream.
 74 |      *
 75 |      * As this is a message-wide setting, ParserUUEncodedPartProxy calls
 76 |      * setNextPartStart() on its parent (a ParserNonMimeMessageProxy, which
 77 |      * stores/returns this information).
 78 |      */
 79 |     public function setNextPartStart(int $nextPartStart) : static
 80 |     {
 81 |         $this->getParent()->setNextPartStart($nextPartStart);
 82 |         return $this;
 83 |     }
 84 | 
 85 |     /**
 86 |      * Sets the next part's unix file mode from its 'begin' line.
 87 |      *
 88 |      * As this is a message-wide setting, ParserUUEncodedPartProxy calls
 89 |      * setNextPartMode() on its parent (a ParserNonMimeMessageProxy, which
 90 |      * stores/returns this information).
 91 |      */
 92 |     public function setNextPartMode(int $nextPartMode) : static
 93 |     {
 94 |         $this->getParent()->setNextPartMode($nextPartMode);
 95 |         return $this;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Sets the next part's filename from its 'begin' line.
100 |      *
101 |      * As this is a message-wide setting, ParserUUEncodedPartProxy calls
102 |      * setNextPartFilename() on its parent (a ParserNonMimeMessageProxy, which
103 |      * stores/returns this information).
104 |      */
105 |     public function setNextPartFilename(string $nextPartFilename) : static
106 |     {
107 |         $this->getParent()->setNextPartFilename($nextPartFilename);
108 |         return $this;
109 |     }
110 | 
111 |     /**
112 |      * Returns the file mode included in the uuencoded 'begin' line for this
113 |      * part.
114 |      */
115 |     public function getUnixFileMode() : ?int
116 |     {
117 |         return $this->getHeaderContainer()->getUnixFileMode();
118 |     }
119 | 
120 |     /**
121 |      * Returns the filename included in the uuencoded 'begin' line for this
122 |      * part.
123 |      */
124 |     public function getFilename() : ?string
125 |     {
126 |         return $this->getHeaderContainer()->getFilename();
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/Parser/NonMimeParserService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Parser;
  9 | 
 10 | use ZBateson\MailMimeParser\Parser\Part\UUEncodedPartHeaderContainerFactory;
 11 | use ZBateson\MailMimeParser\Parser\Proxy\ParserMimePartProxy;
 12 | use ZBateson\MailMimeParser\Parser\Proxy\ParserNonMimeMessageProxy;
 13 | use ZBateson\MailMimeParser\Parser\Proxy\ParserNonMimeMessageProxyFactory;
 14 | use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxy;
 15 | use ZBateson\MailMimeParser\Parser\Proxy\ParserUUEncodedPartProxy;
 16 | use ZBateson\MailMimeParser\Parser\Proxy\ParserUUEncodedPartProxyFactory;
 17 | 
 18 | /**
 19 |  * Parses content for non-mime messages and uu-encoded child parts.
 20 |  *
 21 |  * @author Zaahid Bateson
 22 |  */
 23 | class NonMimeParserService extends AbstractParserService
 24 | {
 25 |     protected UUEncodedPartHeaderContainerFactory $partHeaderContainerFactory;
 26 | 
 27 |     public function __construct(
 28 |         ParserNonMimeMessageProxyFactory $parserNonMimeMessageProxyFactory,
 29 |         ParserUUEncodedPartProxyFactory $parserUuEncodedPartProxyFactory,
 30 |         PartBuilderFactory $partBuilderFactory,
 31 |         UUEncodedPartHeaderContainerFactory $uuEncodedPartHeaderContainerFactory
 32 |     ) {
 33 |         parent::__construct($parserNonMimeMessageProxyFactory, $parserUuEncodedPartProxyFactory, $partBuilderFactory);
 34 |         $this->partHeaderContainerFactory = $uuEncodedPartHeaderContainerFactory;
 35 |     }
 36 | 
 37 |     /**
 38 |      * Always returns true, and should therefore be the last parser reached by
 39 |      * a ParserManager.
 40 |      */
 41 |     public function canParse(PartBuilder $part) : bool
 42 |     {
 43 |         return true;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Creates a UUEncodedPartHeaderContainer attached to a PartBuilder, and
 48 |      * calls $this->parserManager->createParserProxyFor().
 49 |      *
 50 |      * It also sets the PartBuilder's stream part start pos and content start
 51 |      * pos to that of $parent->getNextParStart() (since a 'begin' line is read
 52 |      * prior to another child being created, see parseNextPart()).
 53 |      */
 54 |     private function createPart(ParserNonMimeMessageProxy $parent) : ParserPartProxy
 55 |     {
 56 |         $hc = $this->partHeaderContainerFactory->newInstance($parent->getNextPartMode(), $parent->getNextPartFilename());
 57 |         $pb = $this->partBuilderFactory->newChildPartBuilder($hc, $parent);
 58 |         $proxy = $this->parserManager->createParserProxyFor($pb);
 59 |         $pb->setStreamPartStartPos($parent->getNextPartStart());
 60 |         $pb->setStreamContentStartPos($parent->getNextPartStart());
 61 |         return $proxy;
 62 |     }
 63 | 
 64 |     /**
 65 |      * Reads content from the passed ParserPartProxy's stream till a uu-encoded
 66 |      * 'begin' line is found, setting $proxy->setStreamPartContentAndEndPos() to
 67 |      * the last byte read before the begin line.
 68 |      *
 69 |      * @param ParserNonMimeMessageProxy|ParserUUEncodedPartProxy $proxy
 70 |      */
 71 |     private function parseNextPart(ParserPartProxy $proxy) : static
 72 |     {
 73 |         $handle = $proxy->getMessageResourceHandle();
 74 |         while (!\feof($handle)) {
 75 |             $start = \ftell($handle);
 76 |             $line = \trim(MessageParserService::readLine($handle));
 77 |             if (\preg_match('/^begin ([0-7]{3}) (.*)$/', $line, $matches)) {
 78 |                 $proxy->setNextPartStart($start);
 79 |                 $proxy->setNextPartMode((int) $matches[1]);
 80 |                 $proxy->setNextPartFilename($matches[2]);
 81 |                 return $this;
 82 |             }
 83 |             $proxy->setStreamPartAndContentEndPos(\ftell($handle));
 84 |         }
 85 |         return $this;
 86 |     }
 87 | 
 88 |     public function parseContent(ParserPartProxy $proxy) : static
 89 |     {
 90 |         $handle = $proxy->getMessageResourceHandle();
 91 |         if ($proxy->getNextPartStart() !== null || \feof($handle)) {
 92 |             return $this;
 93 |         }
 94 |         if ($proxy->getStreamContentStartPos() === null) {
 95 |             $proxy->setStreamContentStartPos(\ftell($handle));
 96 |         }
 97 |         $this->parseNextPart($proxy);
 98 |         return $this;
 99 |     }
100 | 
101 |     public function parseNextChild(ParserMimePartProxy $proxy) : ?ParserPartProxy
102 |     {
103 |         $handle = $proxy->getMessageResourceHandle();
104 |         if ($proxy->getNextPartStart() === null || \feof($handle)) {
105 |             return null;
106 |         }
107 |         $child = $this->createPart($proxy);
108 |         $proxy->clearNextPart();
109 |         return $child;
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/src/Message/PartFilter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Message;
  9 | 
 10 | /**
 11 |  * Collection of static methods that return callables for common IMultiPart
 12 |  * child filters.
 13 |  *
 14 |  * @author Zaahid Bateson
 15 |  */
 16 | abstract class PartFilter
 17 | {
 18 |     /**
 19 |      * Provides an 'attachment' filter used by Message::getAttachmentPart.
 20 |      *
 21 |      * The method filters out the following types of parts:
 22 |      *  - text/plain and text/html parts that do not have an 'attachment'
 23 |      *    disposition
 24 |      *  - any part that returns true for isMultiPart()
 25 |      *  - any part that returns true for isSignaturePart()
 26 |      */
 27 |     public static function fromAttachmentFilter() : callable
 28 |     {
 29 |         return function(IMessagePart $part) {
 30 |             $type = $part->getContentType();
 31 |             $disp = $part->getContentDisposition();
 32 |             if (\in_array($type, ['text/plain', 'text/html']) && $disp !== null && \strcasecmp($disp, 'inline') === 0) {
 33 |                 return false;
 34 |             }
 35 |             return !(($part instanceof IMimePart)
 36 |                 && ($part->isMultiPart() || $part->isSignaturePart()));
 37 |         };
 38 |     }
 39 | 
 40 |     /**
 41 |      * Provides a filter that keeps parts that contain a header of $name with a
 42 |      * value that matches $value (case insensitive).
 43 |      *
 44 |      * By default signed parts are excluded. Pass FALSE to the third parameter
 45 |      * to include them.
 46 |      *
 47 |      * @param string $name The header name to look up
 48 |      * @param string $value The value to match
 49 |      * @param bool $excludeSignedParts Optional signed parts exclusion (defaults
 50 |      *        to true).
 51 |      */
 52 |     public static function fromHeaderValue(string $name, string $value, bool $excludeSignedParts = true) : callable
 53 |     {
 54 |         return function(IMessagePart $part) use ($name, $value, $excludeSignedParts) {
 55 |             if ($part instanceof IMimePart) {
 56 |                 if ($excludeSignedParts && $part->isSignaturePart()) {
 57 |                     return false;
 58 |                 }
 59 |                 return (\strcasecmp($part->getHeaderValue($name, ''), $value) === 0);
 60 |             }
 61 |             return false;
 62 |         };
 63 |     }
 64 | 
 65 |     /**
 66 |      * Includes only parts that match the passed $mimeType in the return value
 67 |      * of a call to 'getContentType()'.
 68 |      *
 69 |      * @param string $mimeType Mime type of parts to find.
 70 |      */
 71 |     public static function fromContentType(string $mimeType) : callable
 72 |     {
 73 |         return function(IMessagePart $part) use ($mimeType) {
 74 |             return \strcasecmp($part->getContentType() ?: '', $mimeType) === 0;
 75 |         };
 76 |     }
 77 | 
 78 |     /**
 79 |      * Returns parts matching $mimeType that do not have a Content-Disposition
 80 |      * set to 'attachment'.
 81 |      *
 82 |      * @param string $mimeType Mime type of parts to find.
 83 |      */
 84 |     public static function fromInlineContentType(string $mimeType) : callable
 85 |     {
 86 |         return function(IMessagePart $part) use ($mimeType) {
 87 |             $disp = $part->getContentDisposition();
 88 |             return (\strcasecmp($part->getContentType() ?: '', $mimeType) === 0) && ($disp === null
 89 |                 || \strcasecmp($disp, 'attachment') !== 0);
 90 |         };
 91 |     }
 92 | 
 93 |     /**
 94 |      * Finds parts with the passed disposition (matching against
 95 |      * IMessagePart::getContentDisposition()), optionally including
 96 |      * multipart parts and signed parts.
 97 |      *
 98 |      * @param string $disposition The disposition to find.
 99 |      * @param bool $includeMultipart Optionally include multipart parts by
100 |      *        passing true (defaults to false).
101 |      * @param bool $includeSignedParts Optionally include signed parts (defaults
102 |      *        to false).
103 |      */
104 |     public static function fromDisposition(string $disposition, bool $includeMultipart = false, bool $includeSignedParts = false) : callable
105 |     {
106 |         return function(IMessagePart $part) use ($disposition, $includeMultipart, $includeSignedParts) {
107 |             if (($part instanceof IMimePart) && ((!$includeMultipart && $part->isMultiPart()) || (!$includeSignedParts && $part->isSignaturePart()))) {
108 |                 return false;
109 |             }
110 |             $disp = $part->getContentDisposition();
111 |             return ($disp !== null && \strcasecmp($disp, $disposition) === 0);
112 |         };
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/src/Header/Consumer/ReceivedConsumerService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This file is part of the ZBateson\MailMimeParser project.
  4 |  *
  5 |  * @license http://opensource.org/licenses/bsd-license.php BSD
  6 |  */
  7 | 
  8 | namespace ZBateson\MailMimeParser\Header\Consumer;
  9 | 
 10 | use Iterator;
 11 | use Psr\Log\LoggerInterface;
 12 | use ZBateson\MailMimeParser\Header\Consumer\Received\DomainConsumerService;
 13 | use ZBateson\MailMimeParser\Header\Consumer\Received\GenericReceivedConsumerService;
 14 | use ZBateson\MailMimeParser\Header\Consumer\Received\ReceivedDateConsumerService;
 15 | use ZBateson\MailMimeParser\Header\Part\HeaderPartFactory;
 16 | use ZBateson\MailMimeParser\Header\Part\Token;
 17 | 
 18 | /**
 19 |  * Parses a Received header into ReceivedParts, ReceivedDomainParts, a DatePart,
 20 |  * and CommentParts.
 21 |  *
 22 |  * Parts that don't correspond to any of the above are discarded.
 23 |  *
 24 |  * @author Zaahid Bateson
 25 |  */
 26 | class ReceivedConsumerService extends AbstractConsumerService
 27 | {
 28 |     public function __construct(
 29 |         LoggerInterface $logger,
 30 |         HeaderPartFactory $partFactory,
 31 |         DomainConsumerService $fromDomainConsumerService,
 32 |         DomainConsumerService $byDomainConsumerService,
 33 |         GenericReceivedConsumerService $viaGenericReceivedConsumerService,
 34 |         GenericReceivedConsumerService $withGenericReceivedConsumerService,
 35 |         GenericReceivedConsumerService $idGenericReceivedConsumerService,
 36 |         GenericReceivedConsumerService $forGenericReceivedConsumerService,
 37 |         ReceivedDateConsumerService $receivedDateConsumerService,
 38 |         CommentConsumerService $commentConsumerService
 39 |     ) {
 40 |         parent::__construct(
 41 |             $logger,
 42 |             $partFactory,
 43 |             [
 44 |                 $fromDomainConsumerService,
 45 |                 $byDomainConsumerService,
 46 |                 $viaGenericReceivedConsumerService,
 47 |                 $withGenericReceivedConsumerService,
 48 |                 $idGenericReceivedConsumerService,
 49 |                 $forGenericReceivedConsumerService,
 50 |                 $receivedDateConsumerService,
 51 |                 $commentConsumerService
 52 |             ]
 53 |         );
 54 |     }
 55 | 
 56 |     /**
 57 |      * ReceivedConsumerService doesn't have any token separators of its own.
 58 |      * Sub-Consumers will return separators matching 'part' word separators, for
 59 |      * example 'from' and 'by', and ';' for date, etc...
 60 |      *
 61 |      * @return string[] an array of regex pattern matchers
 62 |      */
 63 |     protected function getTokenSeparators() : array
 64 |     {
 65 |         return [];
 66 |     }
 67 | 
 68 |     /**
 69 |      * ReceivedConsumerService doesn't have an end token, and so this just
 70 |      * returns false.
 71 |      */
 72 |     protected function isEndToken(string $token) : bool
 73 |     {
 74 |         return false;
 75 |     }
 76 | 
 77 |     /**
 78 |      * ReceivedConsumerService doesn't start consuming at a specific token, it's
 79 |      * the base handler for the Received header, and so this always returns
 80 |      * false.
 81 |      *
 82 |      * @codeCoverageIgnore
 83 |      */
 84 |     protected function isStartToken(string $token) : bool
 85 |     {
 86 |         return false;
 87 |     }
 88 | 
 89 |     /**
 90 |      * Overridden to exclude the MimeLiteralPart pattern that comes by default
 91 |      * in AbstractConsumer.
 92 |      *
 93 |      * @return string the regex pattern
 94 |      */
 95 |     protected function getTokenSplitPattern() : string
 96 |     {
 97 |         $sChars = \implode('|', $this->getAllTokenSeparators());
 98 |         return '~(' . $sChars . ')~';
 99 |     }
100 | 
101 |     /**
102 |      * Overridden to /not/ advance when the end token matches a start token for
103 |      * a sub-consumer.
104 |      */
105 |     protected function advanceToNextToken(Iterator $tokens, bool $isStartToken) : static
106 |     {
107 |         if ($isStartToken) {
108 |             $tokens->next();
109 |         } elseif ($tokens->valid() && !$this->isEndToken($tokens->current())) {
110 |             foreach ($this->subConsumers as $consumer) {
111 |                 if ($consumer->isStartToken($tokens->current())) {
112 |                     return $this;
113 |                 }
114 |             }
115 |             $tokens->next();
116 |         }
117 |         return $this;
118 |     }
119 | 
120 |     /**
121 |      * @param \ZBateson\MailMimeParser\Header\IHeaderPart[] $parts
122 |      * @return \ZBateson\MailMimeParser\Header\IHeaderPart[]
123 |      */
124 |     protected function processParts(array $parts) : array
125 |     {
126 |         // filtering out tokens (filters out the names, e.g. 'by' or 'with')
127 |         return \array_values(\array_filter($parts, fn ($p) => !$p instanceof Token));
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------