<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category   Zend

 * @package    Zend_Mime

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

/**

 * @see Zend_Mime

 */

require_once 'Zend/Mime.php';

/**

 * @category   Zend

 * @package    Zend_Mime

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Mime_Decode

{

    /**

     * Explode MIME multipart string into seperate parts

     *

     * Parts consist of the header and the body of each MIME part.

     *

     * @param  string $body     raw body of message

     * @param  string $boundary boundary as found in content-type

     * @return array parts with content of each part, empty if no parts found

     * @throws Zend_Exception

     */

    public static function splitMime($body, $boundary)

    {

        // TODO: we're ignoring \r for now - is this function fast enough and is it safe to asume noone needs \r?

        $body = str_replace("\r", '', $body);

        $start = 0;

        // find every mime part limiter and cut out the

        // string before it.

        // the part before the first boundary string is discarded:

        $p = strpos($body, '--' . $boundary . "\n", $start);

        if ($p === false) {

            // no parts found!

            return array();

        }

        // position after first boundary line

        $start = $p + 3 + strlen($boundary);

        while (($p = strpos($body, '--' . $boundary . "\n", $start)) !== false) {

            $res[] = substr($body, $start, $p-$start);

            $start = $p + 3 + strlen($boundary);

        }

        // no more parts, find end boundary

        $p = strpos($body, '--' . $boundary . '--', $start);

            throw new Zend_Exception('Not a valid Mime Message: End Missing');

        }

        // the remaining part also needs to be parsed:

        return $res;

    }

    /**

     * decodes a mime encoded String and returns a

     * struct of parts with header and body

     *

     * @param  string $message  raw message content

     * @param  string $boundary boundary as found in content-type

     * @return array|null parts as array('header' => array(name => value), 'body' => content), null if no parts found

     * @throws Zend_Exception

     */

    {

        $parts = self::splitMime($message, $boundary);

        if (count($parts) <= 0) {

            return null;

        }

        $result = array();

        foreach ($parts as $part) {

            self::splitMessage($part, $headers, $body, $EOL);

        }

        return $result;

    }

    /**

     * split a message in header and body part, if no header or an

     * invalid header is found $headers is empty

     *

     * The charset of the returned headers depend on your iconv settings.

     *

     * @param  string $message raw message with header and optional content

     * @param  array  $headers output param, array with headers as array(name => value)

     * @param  string $body    output param, content of message

     * @return null

     */

    {

        // check for valid header at first line

        $firstline = strtok($message, "\n");

        if (!preg_match('%^[^\s]+[^:]*:%', $firstline)) {

            $headers = array();

            // TODO: we're ignoring \r for now - is this function fast enough and is it safe to asume noone needs \r?

            return;

        }

        // find an empty line between headers and body

        // default is set new line

        if (strpos($message, $EOL . $EOL)) {

            list($headers, $body) = explode($EOL . $EOL, $message, 2);

        } else {

        }

            // an error occurs during the decoding

            return;

        }

        // normalize header names

        foreach ($headers as $name => $header) {

            $lower = strtolower($name);

            if ($lower == $name) {

                continue;

            }

            unset($headers[$name]);

            if (!isset($headers[$lower])) {

                $headers[$lower] = $header;

                continue;

            }

            if (is_array($headers[$lower])) {

                $headers[$lower][] = $header;

                continue;

            }

        }

    }

    /**

     * split a content type in its different parts

     *

     * @param  string $type       content-type

     * @param  string $wantedPart the wanted part, else an array with all parts is returned

     * @return string|array wanted part or all parts as array('type' => content-type, partname => value)

     */

    public static function splitContentType($type, $wantedPart = null)

    {

        return self::splitHeaderField($type, $wantedPart, 'type');

    }

    /**

     * split a header field like content type in its different parts

     *

     * @return string|array wanted part or all parts as array($firstName => firstPart, partname => value)

     */

    {

        $wantedPart = strtolower($wantedPart);

        // special case - a bit optimized

        if ($firstName === $wantedPart) {

            $field = strtok($field, ';');

            return $field[0] == '"' ? substr($field, 1, -1) : $field;

        }

        $field = $firstName . '=' . $field;

        if (!preg_match_all('%([^=\s]+)\s*=\s*("[^"]+"|[^;]+)(;\s*|$)%', $field, $matches)) {

            throw new Zend_Exception('not a valid header field');

        }

        if ($wantedPart) {

            foreach ($matches[1] as $key => $name) {

                if (strcasecmp($name, $wantedPart)) {

                    continue;

                }

                if ($matches[2][$key][0] != '"') {

                    return $matches[2][$key];

                }

                return substr($matches[2][$key], 1, -1);

            }

            return null;

        }

        $split = array();

        foreach ($matches[1] as $key => $name) {

            $name = strtolower($name);

            if ($matches[2][$key][0] == '"') {

                $split[$name] = substr($matches[2][$key], 1, -1);

            } else {

                $split[$name] = $matches[2][$key];

            }

        }

        return $split;

    }

    /**

     * decode a quoted printable encoded string

     *

     * The charset of the returned string depends on your iconv settings.

     *

     */

    public static function decodeQuotedPrintable($string)

    {

        return quoted_printable_decode($string);

    }

}