MailMimeParser

https://github.com/zbateson/mail-mime-parser
Admin
MailMimeParser is a PHP library for parsing, creating and modifying MIME email messages, with access...
Tokens:34,413
Snippets:64
Trust Score:8
License:BSD-2-Clause
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install MailMimeParser via Composer

Source: https://github.com/zbateson/mail-mime-parser/blob/master/README.md

This command installs the MailMimeParser library into your project using Composer. Composer is a dependency manager for PHP and is required for this installation.

```bash
composer require zbateson/mail-mime-parser
```

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

### MIME Message Structure

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3001.txt

Demonstrates the structure of a MIME-formatted email, including headers, content types, boundaries, and base64-encoded attachments. It shows how different parts of the message are separated and defined.  The example shows 2 image attachments.

```email
Date: Fri, 19 May 2000 09:55:48 -0400 (EDT)
From: Doug Sauder <doug@penguin.example.com>
To: Joe Blow <blow@example.com>
Subject: Test message from PINE
Message-ID: <Pine.LNX.4.21.0005190951410.8452-102000@penguin.example.com>
MIME-Version: 1.0
Content-Type: MULTIPART/MIXED; BOUNDARY="-1463757054-952513540-958744548=:8452"

  This message is in MIME format.  The first part should be readable text,
  while the remaining parts are likely unreadable without MIME-aware tools.
  Send mail to mime@docserver.cac.washington.edu for more info.

---1463757054-952513540-958744548=:8452
Content-Type: TEXT/PLAIN; charset=US-ASCII

This is a test message from PINE MUA.


---1463757054-952513540-958744548=:8452
Content-Type: APPLICATION/octet-stream; name="redball.png"
Content-Transfer-Encoding: BASE64
Content-ID: <Pine.LNX.4.21.0005190955480.8452@penguin.example.com>
Content-Description: A PNG graphic file
Content-Disposition: attachment; filename="redball.png"
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---1463757054-952513540-958744548=:8452
Content-Type: APPLICATION/octet-stream; name="blueball.png"
Content-Transfer-Encoding: BASE64
Content-ID: <Pine.LNX.4.21.0005190955481.8452@penguin.example.com>
Content-Description: A PNG graphic file
Content-Disposition: attachment; filename="blueball.png"

iVBORw0KGgoAAAANSUhEUgAAABsAAAAbCAMAAAC6CgRnAAADAFBMVEX///8A
AAgAABAAABgAAAAACCkAEEIAEEoACDEAEFIIIXMIKXsIKYQIIWsAGFoACDkI
IWMQOZwYQqUYQq0YQrUQOaUQMZQAGFIQMYwpUrU5Y8Y5Y84pWs4YSs4YQs4Y
Qr1Ca8Z7nNacvd6Mtd5jlOcxa94hUt4YStYYQsYQMaUAACHO5+/n7++cxu9S
hO8pWucQOa1Ke86tzt6lzu9ajO8QMZxahNat1ufO7++Mve9Ke+8YOaUYSsaM
vee15++Uve8AAClajOdzpe9rnO8IKYwxY+8pWu8IIXsAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADB
Mg1VAAAAAXRSTlMAQObYZgAAABZ0RVh0U29mdHdhcmUAZ2lmMnBuZyAyLjAu
MT1evmgAAAGISURBVHicddJtV5swGAbgEk6AJhBSk4bMCUynBSLaqovbrG/b
fPn/vyh70lbsscebL5xznTsh5BmNhgQoRChwo50EOIohUYLDj4zHhKYQkrEo
Qdvock4ne0IKMVUpKZLQDeqSTIsv+18PyqqWUw2IBsRM7307PPp+fDJrWtnp
LDJvewYxnewfnvanZ+fzpmwXijC8KbqEa3Fx2ff91Y95U9XCUpaDeQwiMpHX
P/v+1++bWVPWQoGFawtjury9vru/f/C1Vi7ezT0WWpQHf/7+u/G71aLThK/M
jRxmT6KdzZ9fGk9yatMsTgZLl3XVgFRAC6spj/13enssqJVtWVa3NdBSacL8
+VZmYqKmdd1CSYoOiMOSGwtzlqqlFFIuOqv0a1ZEZrUkWICLLFW266y1KvWE
1zV/iDAH1EopnVLCiygZCIomH3NCKX0lnI+B1iuuzCGTxwXjnDO4d7NpbX42
--1463757054-952513540-958744548=:8452--
```

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

### Advanced header manipulation (PHP)

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

This example demonstrates how to set standard and custom headers, add multiple headers with the same name, retrieve header values and parameters (like charset and format from Content-Type), get all headers by name, iterate through all headers, and remove specific headers. It uses the MailMimeParser library in PHP.

```php
<?php
use ZBateson\MailMimeParser\Message;
use ZBateson\MailMimeParser\Header\HeaderConsts;

$message = new Message();

// Set standard headers
$message->setRawHeader(HeaderConsts::FROM, 'alice@example.com');
$message->setRawHeader(HeaderConsts::SUBJECT, 'Test Email');
$message->setRawHeader(HeaderConsts::DATE, date('r'));

// Set custom headers
$message->setRawHeader('X-Mailer', 'MyMailer 1.0');
$message->setRawHeader('X-Priority', '1');

// Add multiple headers with same name
$message->addRawHeader(HeaderConsts::RECEIVED, 'from mx1.example.com by mx2.example.com');
$message->addRawHeader(HeaderConsts::RECEIVED, 'from mx0.example.com by mx1.example.com');

// Get Content-Type with parameters
$message->setRawHeader(
    HeaderConsts::CONTENT_TYPE,
    'text/plain; charset=ISO-8859-1; format=flowed'
);

$contentType = $message->getHeaderValue(HeaderConsts::CONTENT_TYPE);
$charset = $message->getHeaderParameter(HeaderConsts::CONTENT_TYPE, 'charset');
$format = $message->getHeaderParameter(HeaderConsts::CONTENT_TYPE, 'format');

echo "Content-Type: {$contentType}\n";
echo "Charset: {$charset}\n";
echo "Format: {$format}\n";

// Get all headers with a specific name
$receivedHeaders = $message->getAllHeadersByName(HeaderConsts::RECEIVED);
echo "Received headers count: " . count($receivedHeaders) . "\n";

// Iterate all headers
foreach ($message->getAllHeaders() as $header) {
    echo $header->getName() . ": " . $header->getValue() . "\n";
}

// Remove headers
$message->removeSingleHeader(HeaderConsts::RECEIVED, 0);  // Remove first Received header
$message->removeHeader('X-Priority');                      // Remove all X-Priority headers

// Output:
// Content-Type: text/plain; charset=ISO-8859-1; format=flowed
// Charset: ISO-8859-1
// Format: flowed
// Received headers count: 2
// From: alice@example.com
// Subject: Test Email
// [... other headers ...]
?>
```

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

### Basic Mail Parsing Script (Shell)

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

This shell script provides a basic example of how one might process email files, potentially using command-line tools to extract information or content. It's a rudimentary approach compared to dedicated libraries.

```bash
#!/bin/bash

# Example: Process a single email file

EMAIL_FILE="input.eml"

if [ ! -f "$EMAIL_FILE" ]; then
    echo "Error: File '$EMAIL_FILE' not found."
    exit 1
fi

# Extract headers
echo "--- Headers ---"
grep -E '^[a-zA-Z-]+:' "$EMAIL_FILE"

# Extract body (simplified - may not handle multipart correctly)
echo "\n--- Body ---"
grep -v -E '^[a-zA-Z-]+:' "$EMAIL_FILE"

# More advanced parsing would require tools like 'munpack' or dedicated scripts.
```

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

### MIME Multipart Message Parsing (Conceptual)

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m1013.txt

This snippet conceptually represents the structure of a MIME multipart message. It shows how different content types (text/plain and image/png) are separated by a boundary and encoded. This structure is typical for emails containing attachments or rich text content.

```text
Content-Type: multipart/mixed;
 boundary="------------E7889DDF0F75D34163841C59"

This is a multi-part message in MIME format.
--------------E7889DDF0F75D34163841C59
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit

<Plain text content here>
--------------E7889DDF0F75D34163841C59
Content-Type: image/png;
 name="blueball.png"
Content-Transfer-Encoding: base64
Content-Disposition: inline;
 filename="blueball.png"

<Base64 encoded image data here>
--------------E7889DDF0F75D34163841C59--
```

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

### Base64 Encoded PNG Image Data

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m1013.txt

This snippet contains the base64 encoded data for a PNG image named 'blueball.png'. Base64 encoding is commonly used to represent binary data, such as images, in a text-based format, making it suitable for inclusion in emails or other text-based protocols.

```base64
iVBORw0KGgoAAAANSUhEUgAAABsAAAAbCAMAAAC6CgRnAAADAFBMVEX///8AAAgAABAAABgA
AAAACCkAEEIAEEoACDEAEFIIIXMIKXsIKYQIIWsAGFoACDkIIWMQOZwYQqUYQq0YQrUQOaUQ
MZQAGFIQMYwpUrU5Y8Y5Y84pWs4YSs4YQs4YQr1Ca8Z7nNacvd6Mtd5jlOcxa94hUt4YStYY
QsYQMaUAACHO5+/n7++cxu9ShO8pWucQOa1Ke86tzt6lzu9ajO8QMZxahNat1ufO7++Mve9K
e+8YOaUYSsaMvee15++Uve8AAClajOdzpe9rnO8IKYwxY+8pWu8IIXsAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADB
Mg1VAAAAAXRSTlMAQObYZgAAABZ0RVh0U29mdHdhcmUAZ2lmMnBuZyAyLjAuMT1evmgAAAGI
SURBVHicddJtV5swGAbgEk6AJhBSk4bMCUynBSLaqovbrG/bfPn/vyh70lbsscebL5xznTsh
5BmNhgQoRChwo50EOIohUYLDj4zHhKYQkrEoQdvock4ne0IKMVUpKZLQDeqSTIsv+18PyqqW
Uw2IBsRM7307PPp+fDJrWtnpLDJvewYxnewfnvanZ+fzpmwXijC8KbqEa3Fx2ff91Y95U9XC
UpaDeQwiMpHXP/v+1++bWVPWQoGFawtjury9vru/f/C1Vi7ezT0WWpQHf/7+u/G71aLThK/M
jRxmT6KdzZ9fGk9yatMsTgZLl3XVgFRAC6spj/13enssqJVtWVa3NdBSacL8+VZmYqKmdd1C
SYoOiMOSGwtzlqqlFFIuOqv0a1ZEZrUkWICLLFW266y1KvWE1zV/iDAH1EopnVLCiygZCIom
H3NCKX0lnI+B1iuuzCGTxwXjnDO4d7NpbX42YJJHkBwmAm2TxwAZg40J3+Xtbv1rgOAZwG0N
xW62p+lT+Yi747sD/wEUVMzYmWkOvwAAACV0RVh0Q29tbWVudABjbGlwMmdpZiB2LjAuNiBi
4YVesmgAAAAASUVORK5CYII=
```

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

### Handle multipart/signed messages (PHP)

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

This snippet demonstrates how to create a message, set it as multipart/signed, generate a signature (using a placeholder for actual signing functions), attach the signature, save the message, and later verify the signature. It covers both S/MIME and PGP signature handling.

```php
<?php
use ZBateson\MailMimeParser\Message;

// Create a message and prepare for signing
$message = new Message();
$message->setRawHeader('From', 'alice@example.com');
$message->setRawHeader('To', 'bob@example.com');
$message->setRawHeader('Subject', 'Signed Message');
$message->setTextPart('This message will be signed.');

// Convert to multipart/signed format
$message->setAsMultipartSigned('sha256', 'application/pgp-signature');

// Get normalized content to sign
$contentToSign = $message->getSignedMessageAsString();

// Generate signature (example using external signing)
// In real usage, use openssl or gpg functions
$signature = "----BEGIN PGP SIGNATURE-----
" 
    . base64_encode(hash('sha256', $contentToSign, true))
    . "\n-----END PGP SIGNATURE-----";

// Attach the signature
$message->setSignature($signature);

// Save signed message
$message->save('/tmp/signed-message.eml');

// Later, verify the signature
$signedMessage = Message::from(fopen('/tmp/signed-message.eml', 'r'), true);
$signaturePart = $signedMessage->getSignaturePart();

if ($signaturePart) {
    echo "Signature found:\n";
    echo $signaturePart->getContent() . "\n";

    // Get signed content for verification
    $signedContent = $signedMessage->getSignedMessageAsString();

    // Verify signature (implementation depends on signature type)
    echo "Content to verify hash: " . hash('sha256', $signedContent) . "\n";
}

// Output:
// Signature found:
// -----BEGIN PGP SIGNATURE-----
// [base64 encoded signature]
// -----END PGP SIGNATURE-----
// Content to verify hash: [hash value]
?>
```

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

### Custom Dependency Injection in PHP

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

Shows how to configure custom services and logging for the mail-mime-parser using a PHP-DI container. It covers passing a logger to a single instance, setting a global logger, using custom PHP-DI configurations, applying per-instance configurations, and directly manipulating the global container.

```php
<?php
use ZBateson\MailMimeParser\MailMimeParser;
use Psr\Log\LoggerInterface;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

// Create custom logger
$logger = new Logger('custom-parser');
$logger->pushHandler(new StreamHandler('/var/log/mail-parser.log', Logger::WARNING));

// Option 1: Pass logger to single instance
$parser = new MailMimeParser($logger);

// Option 2: Set global logger for all instances
MailMimeParser::setGlobalLogger($logger);
$parser1 = new MailMimeParser();
$parser2 = new MailMimeParser();  // Also uses global logger

// Option 3: Custom PHP-DI configuration
$customConfig = [
    LoggerInterface::class => $logger,
    'custom.setting' => 'value'
];

MailMimeParser::addGlobalPhpDiContainerDefinition($customConfig);

// Option 4: Per-instance custom configuration
$instanceConfig = [
    'instance.specific' => 'config'
];
$parser = new MailMimeParser(null, $instanceConfig, true);

// Option 5: Use container directly
$container = MailMimeParser::getGlobalContainer();
$container->set('MyCustomService', function() {
    return new \MyNamespace\CustomService();
});

// Reset global configuration
MailMimeParser::resetGlobalPhpDiContainerDefinitions();

echo "Custom configuration applied\n";

// Output:
// Custom configuration applied

```

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

### Get email subject with Python

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

Retrieves the subject line from an email message. This is a common requirement for email processing and organization.

```python
def get_email_subject(message):
    """Gets the subject of an email message.

    Args:
        message: An email.message.Message object.

    Returns:
        The subject of the email as a string, or None if not found.
    """
    return message.get('Subject')
```

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

### Create and Modify Email Messages (PHP)

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

Demonstrates creating new email messages from scratch or modifying existing ones. This includes setting headers, adding text and HTML content, and attaching files or data as attachments. It also shows how to remove parts like the HTML part and update text content. Requires the MailMimeParser library.

```php
<?php
use ZBateson\MailMimeParser\Message;
use ZBateson\MailMimeParser\Header\HeaderConsts;

// Create a new message
$message = new Message();

// Set headers
$message->setRawHeader(HeaderConsts::FROM, 'sender@example.com');
$message->setRawHeader(HeaderConsts::TO, 'recipient@example.com');
$message->setRawHeader(HeaderConsts::SUBJECT, 'Welcome Email');

// Set text and HTML content
$message->setTextPart('Welcome! This is the plain text version.');
$message->setHtmlPart('<html><body><h1>Welcome!</h1><p>This is the HTML version.</p></body></html>');

// Add an attachment from file
$message->addAttachmentPartFromFile(
    '/path/to/document.pdf',
    'application/pdf',
    'welcome-guide.pdf',
    'attachment',
    'base64'
);

// Add an attachment from string/resource
$csvData = "Name,Email\nJohn,john@example.com\n";
$message->addAttachmentPart(
    $csvData,
    'text/csv',
    'contacts.csv',
    'attachment',
    'base64'
);

// Save complete message to file
$message->save('/tmp/new-message.eml');

// Or get as string
$emailString = (string)$message;

// Modify existing message - remove HTML part
$existingMessage = Message::from($emailString, false);
$existingMessage->removeHtmlPart(0);
$existingMessage->setTextPart('Updated text content only.');

echo "Message created and modified successfully\n";
?>

```

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

### Get email sender with Python

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

Retrieves the sender's email address and name from an email message. It parses the 'From' header for this information.

```python
from email.header import decode_header

def get_email_sender(message):
    """Gets the sender of an email message.

    Args:
        message: An email.message.Message object.

    Returns:
        A tuple containing the sender's name and email address, or None if not found.
    """
    sender = message.get('From')
    if sender:
        decoded_sender = decode_header(sender)
        # Basic parsing, might need more robust handling for complex From headers
        name = decoded_sender[0][0]
        email = decoded_sender[-1][0]
        if isinstance(name, bytes):
            name = name.decode()
        if isinstance(email, bytes):
            email = email.decode()
        return name, email
    return None
```

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

### Get email recipient with Python

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

Retrieves the recipient's email address and name from an email message. It parses the 'To' or 'Cc' headers.

```python
from email.header import decode_header

def get_email_recipients(message):
    """Gets the recipients (To and Cc) of an email message.

    Args:
        message: An email.message.Message object.

    Returns:
        A list of tuples, where each tuple contains the recipient's name and email address.
    """
    recipients = []
    for header in ['To', 'Cc']:
        header_value = message.get(header)
        if header_value:
            decoded_recipients = decode_header(header_value)
            for name, email_addr in decoded_recipients:
                if isinstance(name, bytes):
                    name = name.decode()
                if isinstance(email_addr, bytes):
                    email_addr = email_addr.decode()
                # Assuming email_addr is the actual email, name might be display name
                recipients.append((name, email_addr))
    return recipients
```

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

### Java SMTP Server for MIME Sample Creation

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/README.md

A simple Java program that acts as an SMTP server to receive email messages directly from a MUA. This is useful for creating genuine MIME samples without modifications by intermediate mail servers. It records the client/server dialog, and the output needs to be edited to extract the email message itself.

```java
import java.io.*;
import java.net.*;

public class SmtpServer {
    public static void main(String[] args) throws Exception {
        int port = 25;
        ServerSocket serverSocket = new ServerSocket(port);
        System.out.println("SMTP Server started on port " + port);

        while (true) {
            Socket clientSocket = serverSocket.accept();
            System.out.println("Client connected: " + clientSocket.getInetAddress());
            
            new Thread(() -> {
                try {
                    BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                    PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

                    out.println("220 smtp.example.com ESMTP"); // EHLO response

                    String line;
                    while ((line = in.readLine()) != null) {
                        System.out.println("Received: " + line);
                        if (line.toUpperCase().startsWith("EHLO")) {
                            out.println("250-smtp.example.com");
                            out.println("250 HELP");
                        } else if (line.toUpperCase().startsWith("MAIL FROM:")) {
                            out.println("250 OK");
                        } else if (line.toUpperCase().startsWith("RCPT TO:")) {
                            out.println("250 OK");
                        } else if (line.toUpperCase().equals("DATA")) {
                            out.println("354 Start mail input; end with <CRLF>.<CRLF>");
                            String dataLine;
                            StringBuilder emailContent = new StringBuilder();
                            while (!(dataLine = in.readLine()).equals(".")) {
                                emailContent.append(dataLine).append("\n");
                            }
                            System.out.println("--- Email Data ---\n" + emailContent.toString());
                            out.println("250 OK: queued as 12345");
                        } else if (line.toUpperCase().equals("QUIT")) {
                            out.println("221 Bye");
                            break;
                        } else {
                            out.println("500 Unrecognized command");
                        }
                    }
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
```

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

### Get HTML body with Python

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

Extracts the HTML part of an email message's body. It prioritizes HTML content for richer display, handling multipart messages.

```python
def get_html_body(message):
    """Gets the HTML body of an email message.

    Args:
        message: An email.message.Message object.

    Returns:
        The HTML body as a string, or None if not found.
    """
    html_body = None
    if message.is_multipart():
        for part in message.walk():
            content_type = part.get_content_type()
            content_disposition = part.get('Content-Disposition')
            if content_type == 'text/html' and content_disposition is None:
                html_body = part.get_payload(decode=True)
                if isinstance(html_body, bytes):
                    html_body = html_body.decode(errors='ignore')
                break
    else:
        content_type = message.get_content_type()
        if content_type == 'text/html':
            html_body = message.get_payload(decode=True)
            if isinstance(html_body, bytes):
                html_body = html_body.decode(errors='ignore')
    return html_body
```

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

### Get plain text body with Python

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

Extracts the plain text part of an email message's body. It handles multipart messages by looking for the 'text/plain' content type.

```python
def get_plain_text_body(message):
    """Gets the plain text body of an email message.

    Args:
        message: An email.message.Message object.

    Returns:
        The plain text body as a string, or None if not found.
    """
    text_body = None
    if message.is_multipart():
        for part in message.walk():
            content_type = part.get_content_type()
            content_disposition = part.get('Content-Disposition')
            if content_type == 'text/plain' and content_disposition is None:
                text_body = part.get_payload(decode=True)
                if isinstance(text_body, bytes):
                    text_body = text_body.decode(errors='ignore')
                break
    else:
        content_type = message.get_content_type()
        if content_type == 'text/plain':
            text_body = message.get_payload(decode=True)
            if isinstance(text_body, bytes):
                text_body = text_body.decode(errors='ignore')
    return text_body
```

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

### Error Handling and Validation in PHP

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

Illustrates how to access parsing errors and validation issues within the mail-mime-parser library, leveraging PSR-3 logging. It shows how to set up a logger, parse potentially malformed emails, check for errors, retrieve errors by severity, and handle exceptions during attachment access.

```php
<?php
use ZBateson\MailMimeParser\MailMimeParser;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

// Set up logging
$logger = new Logger('mail-parser');
$logger->pushHandler(new StreamHandler('/tmp/parser.log', Logger::DEBUG));

// Create parser with logger
$parser = new MailMimeParser($logger);

// Parse potentially malformed message
$malformedEmail = "From: broken@example.com\r\n"
    . "Subject: Test\r\n"
    . "Content-Type: multipart/mixed; boundary=\r\n"  // Missing boundary value
    . "\r\n"
    . "Body content\r\n";

$message = $parser->parse($malformedEmail, false);

// Check for errors
if ($message->hasErrors()) {
    echo "Parsing errors found:\n";
    foreach ($message->getAllErrors() as $error) {
        echo "  - " . $error->getMessage() . " (Level: " . $error->getLevel() . ")\n";
        echo "    Context: " . $error->getPsrLevel() . "\n";
    }
}

// Get errors with specific severity
$criticalErrors = $message->getErrorsWithLogLevel(\Psr\Log\LogLevel::ERROR);
echo "\nCritical errors: " . count($criticalErrors) . "\n";

// Check specific headers for errors
$fromHeader = $message->getHeader('From');
if ($fromHeader && $fromHeader->hasErrors()) {
    echo "From header has errors\n";
}

// Access attachment with error handling
try {
    $attachment = $message->getAttachmentPart(0);
    if ($attachment) {
        $content = $attachment->getContent();
    }
} catch (\Exception $e) {
    echo "Error reading attachment: " . $e->getMessage() . "\n";
}

// Output:
// Parsing errors found:
//   - Boundary value missing in Content-Type header (Level: error)
//     Context: error
//
// Critical errors: 1

```

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

### Email Headers and MIME Structure

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m4008.txt

This section details the initial headers of a MIME-encoded email, including Message-ID, Date, From, To, Subject, and Content-Type. It highlights the multipart nature of the email with boundaries and signing information, indicating a structured email format.

```email
Message-ID: <39235FC5.276CCE00@example.com>
Date: Wed, 17 May 2000 23:13:09 -0400
From: Doug Sauder <dwsauder@example.com>
X-Mailer: Mozilla 4.7 [en] (WinNT; I)
X-Accept-Language: en
MIME-Version: 1.0
To: Heinz =?iso-8859-1?Q?M=FCller?= <mueller@example.com>
Subject: Die Hasen und die =?iso-8859-1?Q?Fr=F6sche?= (Netscape Messenger 4.7)
Content-Type: multipart/signed;
    boundary="----=MMP-57d495ede8684.57d495edeb0d04.56408213";
    micalg="pgp-sha256"; protocol="application/x-pgp-signature"

------=MMP-57d495ede8684.57d495edeb0d04.56408213
Content-Type: multipart/mixed;
 boundary="------------A1E83A41894D3755390B838A"

This is a multi-part message in MIME format.
--------------A1E83A41894D3755390B838A
Content-Type: multipart/alternative;
 boundary="------------F03F94BA73D3B9E8C1B94D92"
```

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

### Get MIME message headers in Python

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

This Python code snippet illustrates how to retrieve the headers of a MIME-encoded email message. It uses the `email` module to parse the message and then accesses the headers dictionary. This is useful for inspecting metadata like 'From', 'To', and 'Subject'.

```python
import email

def get_mime_headers(mime_message_string):
    """Retrieves the headers from a MIME message string.

    Args:
        mime_message_string (str): The raw MIME message as a string.

    Returns:
        dict: A dictionary containing the email headers.
    """
    msg = email.message_from_string(mime_message_string)
    headers = {}
    for key in msg.keys():
        headers[key] = msg.get(key)
    return headers

# Example usage:
# raw_email = """...your raw email string here..."""
# email_headers = get_mime_headers(raw_email)
# print(email_headers.get('Subject'))
# print(email_headers.get('From'))
```

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

### Handle Charset Encoding in PHP

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

Demonstrates how to work with different character encodings and perform charset conversions when parsing email content. It shows how to retrieve content in its original charset, convert it to UTF-8, specify a target charset, and override incorrect charset information.

```php
<?php
use ZBateson\MailMimeParser\Message;
use ZBateson\MailMimeParser\MailMimeParser;

$rawEmail = "Content-Type: text/plain; charset=ISO-8859-1\r\n"
    . "Subject: Grüße\r\n"
    . "\r\n"
    . "Grüße aus Deutschland!\r\n";

$message = Message::from($rawEmail, false);

// Get content in original charset
$part = $message->getTextPart(0);
echo "Original charset: " . $part->getCharset() . "\n";

// Get content converted to UTF-8 (default)
$utf8Content = $message->getTextContent(0, MailMimeParser::DEFAULT_CHARSET);
echo "UTF-8 content: {$utf8Content}\n";

// Get content in specific charset
$isoContent = $message->getTextContent(0, 'ISO-8859-1');
echo "ISO-8859-1 content: {$isoContent}\n";

// Override charset if incorrectly specified
$part->setCharsetOverride('UTF-8', false);
$correctedContent = $part->getContent();
echo "Corrected content: {$correctedContent}\n";

// Set charset override only if none specified
$part->setCharsetOverride('UTF-8', true);

// Work with streams in specific charset
$stream = $message->getTextStream(0, 'UTF-8');
while (!$stream->eof()) {
    echo $stream->read(1024);
}

// Output:
// Original charset: ISO-8859-1
// UTF-8 content: Grüße aus Deutschland!
// ISO-8859-1 content: [ISO-8859-1 encoded bytes]
// Corrected content: Grüße aus Deutschland!

```

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

### Parse MIME Message from File Handle in PHP

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

Demonstrates parsing an email message from a file handle using MailMimeParser. It handles automatic resource management and provides access to basic headers and message content (plain text and HTML). Dependencies include the MailMimeParser class.

```php
<?php
use ZBateson\MailMimeParser\MailMimeParser;
use ZBateson\MailMimeParser\Header\HeaderConsts;

$parser = new MailMimeParser();
$handle = fopen('/path/to/email.eml', 'r');

// Parse with handle attached (auto-closes when message destroyed)
$message = $parser->parse($handle, true);

// Access basic headers
echo $message->getSubject() . "\n";
echo $message->getHeaderValue(HeaderConsts::FROM) . "\n";
echo $message->getHeaderValue(HeaderConsts::TO) . "\n";
echo $message->getHeaderValue(HeaderConsts::DATE) . "\n";

// Get message content
echo $message->getTextContent();      // Plain text version
echo $message->getHtmlContent();      // HTML version

// Output:
// Meeting Tomorrow
// sender@example.com
// recipient@example.com
// Mon, 14 Oct 2025 10:30:00 +0000
// Let's meet at 3pm...

```

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

### Read and Save Email Attachments (PHP)

Source: https://context7.com/zbateson/mail-mime-parser/llms.txt

Demonstrates how to access, enumerate, and save email attachments. It covers retrieving attachment metadata like filename, MIME type, and size, and shows methods for saving content directly to a file or as a string. Assumes the MailMimeParser library is included.

```php
<?php
use ZBateson\MailMimeParser\Message;

$handle = fopen('/path/to/email-with-attachments.eml', 'r');
$message = Message::from($handle, true);

// Count attachments
$attachmentCount = $message->getAttachmentCount();
echo "Found {$attachmentCount} attachment(s)\n";

// Iterate through all attachments
for ($i = 0; $i < $attachmentCount; $i++) {
    $attachment = $message->getAttachmentPart($i);

    // Get attachment metadata
    $filename = $attachment->getFilename();
    $mimeType = $attachment->getContentType();
    $size = $attachment->getBinaryContentStream()->getSize();

    echo "Attachment {$i}: {$filename}\n";
    echo "  Type: {$mimeType}\n";
    echo "  Size: {$size} bytes\n";

    // Save to file (automatically decodes base64/quoted-printable)
    $attachment->saveContent("/tmp/attachments/{$filename}");

    // Or get content as string
    $content = $attachment->getContent();

    // Or copy to stream
    $stream = $attachment->getContentStream();
    $destHandle = fopen("/tmp/copy-{$filename}", 'w');
    while (!$stream->eof()) {
        fwrite($destHandle, $stream->read(8192));
    }
    fclose($destHandle);
}

// Output:
// Found 2 attachment(s)
// Attachment 0: document.pdf
//   Type: application/pdf
//   Size: 245760 bytes
// Attachment 1: image.jpg
//   Type: image/jpeg
//   Size: 102400 bytes
?>
```

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

### Parse Email Message with MailMimeParser

Source: https://github.com/zbateson/mail-mime-parser/blob/master/README.md

Demonstrates how to parse an email message from a file handle or a string using the MailMimeParser class. It shows how to instantiate the parser and retrieve the parsed message object. The parser can handle various input types like strings, resources, or PSR-7 streams.

```php
use ZBateson\MailMimeParser\MailMimeParser;
use ZBateson\MailMimeParser\Message;
use ZBateson\MailMimeParser\Header\HeaderConsts;

// use an instance of MailMimeParser as a class dependency
$mailParser = new MailMimeParser();

// parse() accepts a string, resource or Psr7 StreamInterface
// pass `true` as the second argument to attach the passed $handle and close
// it when the returned IMessage is destroyed.
$handle = fopen('file.mime', 'r');
$message = $mailParser->parse($handle, false);         // returns `IMessage` 

// OR: use this procedurally (Message::from also accepts a string,
// resource or Psr7 StreamInterface
// true or false as second parameter doesn't matter if passing a string.
$string = "Content-Type: text/plain\r\nSubject: Test\r\n\r\nMessage";
$message = Message::from($string, false);
```

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

### Parse MIME Message in Go

Source: https://github.com/zbateson/mail-mime-parser/blob/master/tests/_data/emails/m3005.txt

This Go code snippet shows how to parse a MIME message using the `mime/message` package. It reads from an `io.Reader` and allows access to the message's headers and body.

```go
package main

import (
	"fmt"
	"io"
	"mime/message"
	"strings"
)

func main() {
	// Assume 'mimeMessageString' contains the MIME-encoded email
	mimeMessageString := "..."

	reader := strings.NewReader(mimeMessageString)

	msg, err := message.Read(reader)
	if err != nil {
		fmt.Println("Error reading message:", err)
		return
	}

	// Access headers
	ssubject := msg.Header.Get("Subject")
	fmt.Println("Subject:", subject)

	// Access body (example for simple text part)
	mediaType, params, err := msg.Body.ContentType()
	if err != nil {
		fmt.Println("Error getting content type:", err)
		return
	}

	if mediaType == "text/plain" {
		bodyReader, err := msg.Body.Reader()
		if err != nil {
			fmt.Println("Error getting body reader:", err)
			return
		}
		bodyBytes, err := io.ReadAll(bodyReader)
		if err != nil {
			fmt.Println("Error reading body:", err)
			return
		}
		fmt.Println("Body:", string(bodyBytes))
	}
}
```
Tokens:
Raw