Your IP : 192.168.165.1
<?php
/**
* Copyright 1999-2017 Horde LLC (http://www.horde.org/)
*
* See the enclosed file LICENSE for license information (LGPL). If you
* did not receive this file, see http://www.horde.org/licenses/lgpl21.
*
* @category Horde
* @copyright 1999-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Mime
*/
/**
* Object-oriented representation of a MIME part (RFC 2045-2049).
*
* @author Chuck Hagenbuch <chuck@horde.org>
* @author Michael Slusarz <slusarz@horde.org>
* @category Horde
* @copyright 1999-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Mime
*/
class Horde_Mime_Part
implements ArrayAccess, Countable, RecursiveIterator, Serializable
{
/* Serialized version. */
const VERSION = 2;
/* The character(s) used internally for EOLs. */
const EOL = "\n";
/* The character string designated by RFC 2045 to designate EOLs in MIME
* messages. */
const RFC_EOL = "\r\n";
/* The default encoding. */
const DEFAULT_ENCODING = 'binary';
/* Constants indicating the valid transfer encoding allowed. */
const ENCODE_7BIT = 1;
const ENCODE_8BIT = 2;
const ENCODE_BINARY = 4;
/* MIME nesting limit. */
const NESTING_LIMIT = 100;
/* Status mask value: Need to reindex the current part. */
const STATUS_REINDEX = 1;
/* Status mask value: This is the base MIME part. */
const STATUS_BASEPART = 2;
/**
* The default charset to use when parsing text parts with no charset
* information.
*
* @todo Make this a non-static property or pass as parameter to static
* methods in Horde 6.
*
* @var string
*/
public static $defaultCharset = 'us-ascii';
/**
* The memory limit for use with the PHP temp stream.
*
* @var integer
*/
public static $memoryLimit = 2097152;
/**
* Parent object. Value only accurate when iterating.
*
* @since 2.8.0
*
* @var Horde_Mime_Part
*/
public $parent = null;
/**
* Default value for this Part's size.
*
* @var integer
*/
protected $_bytes;
/**
* The body of the part. Always stored in binary format.
*
* @var resource
*/
protected $_contents;
/**
* The sequence to use as EOL for this part.
*
* The default is currently to output the EOL sequence internally as
* just "\n" instead of the canonical "\r\n" required in RFC 822 & 2045.
* To be RFC complaint, the full <CR><LF> EOL combination should be used
* when sending a message.
*
* @var string
*/
protected $_eol = self::EOL;
/**
* The MIME headers for this part.
*
* @var Horde_Mime_Headers
*/
protected $_headers;
/**
* The charset to output the headers in.
*
* @var string
*/
protected $_hdrCharset = null;
/**
* Metadata.
*
* @var array
*/
protected $_metadata = array();
/**
* The MIME ID of this part.
*
* @var string
*/
protected $_mimeid = null;
/**
* The subparts of this part.
*
* @var array
*/
protected $_parts = array();
/**
* Status mask for this part.
*
* @var integer
*/
protected $_status = 0;
/**
* Temporary array.
*
* @var array
*/
protected $_temp = array();
/**
* The desired transfer encoding of this part.
*
* @var string
*/
protected $_transferEncoding = self::DEFAULT_ENCODING;
/**
* Flag to detect if a message failed to send at least once.
*
* @var boolean
*/
protected $_failed = false;
/**
* Constructor.
*/
public function __construct()
{
$this->_headers = new Horde_Mime_Headers();
/* Mandatory MIME headers. */
$this->_headers->addHeaderOb(
new Horde_Mime_Headers_ContentParam_ContentDisposition(null, '')
);
$ct = Horde_Mime_Headers_ContentParam_ContentType::create();
$ct['charset'] = self::$defaultCharset;
$this->_headers->addHeaderOb($ct);
}
/**
* Function to run on clone.
*/
public function __clone()
{
foreach ($this->_parts as $k => $v) {
$this->_parts[$k] = clone $v;
}
$this->_headers = clone $this->_headers;
if (!empty($this->_contents)) {
$this->_contents = $this->_writeStream($this->_contents);
}
}
/**
* Set the content-disposition of this part.
*
* @param string $disposition The content-disposition to set ('inline',
* 'attachment', or an empty value).
*/
public function setDisposition($disposition = null)
{
$this->_headers['content-disposition']->setContentParamValue(
strval($disposition)
);
}
/**
* Get the content-disposition of this part.
*
* @return string The part's content-disposition. An empty string means
* no desired disposition has been set for this part.
*/
public function getDisposition()
{
return $this->_headers['content-disposition']->value;
}
/**
* Add a disposition parameter to this part.
*
* @param string $label The disposition parameter label.
* @param string $data The disposition parameter data. If null, removes
* the parameter (@since 2.8.0).
*/
public function setDispositionParameter($label, $data)
{
$cd = $this->_headers['content-disposition'];
if (is_null($data)) {
unset($cd[$label]);
} elseif (strlen($data)) {
$cd[$label] = $data;
if (strcasecmp($label, 'size') === 0) {
// RFC 2183 [2.7] - size parameter
$this->_bytes = $cd[$label];
} elseif ((strcasecmp($label, 'filename') === 0) &&
!strlen($cd->value)) {
/* Set part to attachment if not already explicitly set to
* 'inline'. */
$cd->setContentParamValue('attachment');
}
}
}
/**
* Get a disposition parameter from this part.
*
* @param string $label The disposition parameter label.
*
* @return string The data requested.
* Returns null if $label is not set.
*/
public function getDispositionParameter($label)
{
$cd = $this->_headers['content-disposition'];
return $cd[$label];
}
/**
* Get all parameters from the Content-Disposition header.
*
* @return array An array of all the parameters
* Returns the empty array if no parameters set.
*/
public function getAllDispositionParameters()
{
return $this->_headers['content-disposition']->params;
}
/**
* Set the name of this part.
*
* @param string $name The name to set.
*/
public function setName($name)
{
$this->setDispositionParameter('filename', $name);
$this->setContentTypeParameter('name', $name);
}
/**
* Get the name of this part.
*
* @param boolean $default If the name parameter doesn't exist, should we
* use the default name from the description
* parameter?
*
* @return string The name of the part.
*/
public function getName($default = false)
{
if (!($name = $this->getDispositionParameter('filename')) &&
!($name = $this->getContentTypeParameter('name')) &&
$default) {
$name = preg_replace('|\W|', '_', $this->getDescription(false));
}
return $name;
}
/**
* Set the body contents of this part.
*
* @param mixed $contents The part body. Either a string or a stream
* resource, or an array containing both.
* @param array $options Additional options:
* - encoding: (string) The encoding of $contents.
* DEFAULT: Current transfer encoding value.
* - usestream: (boolean) If $contents is a stream, should we directly
* use that stream?
* DEFAULT: $contents copied to a new stream.
*/
public function setContents($contents, $options = array())
{
if (is_resource($contents) && ($contents === $this->_contents)) {
return;
}
if (empty($options['encoding'])) {
$options['encoding'] = $this->_transferEncoding;
}
$fp = (empty($options['usestream']) || !is_resource($contents))
? $this->_writeStream($contents)
: $contents;
/* Properly close the existing stream. */
$this->clearContents();
$this->setTransferEncoding($options['encoding']);
$this->_contents = $this->_transferDecode($fp, $options['encoding']);
}
/**
* Add to the body contents of this part.
*
* @param mixed $contents The part body. Either a string or a stream
* resource, or an array containing both.
* - encoding: (string) The encoding of $contents.
* DEFAULT: Current transfer encoding value.
* - usestream: (boolean) If $contents is a stream, should we directly
* use that stream?
* DEFAULT: $contents copied to a new stream.
*/
public function appendContents($contents, $options = array())
{
if (empty($this->_contents)) {
$this->setContents($contents, $options);
} else {
$fp = (empty($options['usestream']) || !is_resource($contents))
? $this->_writeStream($contents)
: $contents;
$this->_writeStream((empty($options['encoding']) || ($options['encoding'] == $this->_transferEncoding)) ? $fp : $this->_transferDecode($fp, $options['encoding']), array('fp' => $this->_contents));
unset($this->_temp['sendTransferEncoding']);
}
}
/**
* Clears the body contents of this part.
*/
public function clearContents()
{
if (!empty($this->_contents)) {
fclose($this->_contents);
$this->_contents = null;
unset($this->_temp['sendTransferEncoding']);
}
}
/**
* Return the body of the part.
*
* @param array $options Additional options:
* - canonical: (boolean) Returns the contents in strict RFC 822 &
* 2045 output - namely, all newlines end with the
* canonical <CR><LF> sequence.
* DEFAULT: No
* - stream: (boolean) Return the body as a stream resource.
* DEFAULT: No
*
* @return mixed The body text (string) of the part, null if there is no
* contents, and a stream resource if 'stream' is true.
*/
public function getContents($options = array())
{
return empty($options['canonical'])
? (empty($options['stream']) ? $this->_readStream($this->_contents) : $this->_contents)
: $this->replaceEOL($this->_contents, self::RFC_EOL, !empty($options['stream']));
}
/**
* Decodes the contents of the part to binary encoding.
*
* @param resource $fp A stream containing the data to decode.
* @param string $encoding The original file encoding.
*
* @return resource A new file resource with the decoded data.
*/
protected function _transferDecode($fp, $encoding)
{
/* If the contents are empty, return now. */
fseek($fp, 0, SEEK_END);
if (ftell($fp)) {
switch ($encoding) {
case 'base64':
try {
return $this->_writeStream($fp, array(
'error' => true,
'filter' => array(
'convert.base64-decode' => array()
)
));
} catch (ErrorException $e) {}
rewind($fp);
return $this->_writeStream(base64_decode(stream_get_contents($fp)));
case 'quoted-printable':
try {
return $this->_writeStream($fp, array(
'error' => true,
'filter' => array(
'convert.quoted-printable-decode' => array()
)
));
} catch (ErrorException $e) {}
// Workaround for Horde Bug #8747
rewind($fp);
return $this->_writeStream(quoted_printable_decode(stream_get_contents($fp)));
case 'uuencode':
case 'x-uuencode':
case 'x-uue':
/* Support for uuencoded encoding - although not required by
* RFCs, some mailers may still encode this way. */
$res = Horde_Mime::uudecode($this->_readStream($fp));
return $this->_writeStream($res[0]['data']);
}
}
return $fp;
}
/**
* Encodes the contents of the part as necessary for transport.
*
* @param resource $fp A stream containing the data to encode.
* @param string $encoding The encoding to use.
*
* @return resource A new file resource with the encoded data.
*/
protected function _transferEncode($fp, $encoding)
{
$this->_temp['transferEncodeClose'] = true;
switch ($encoding) {
case 'base64':
/* Base64 Encoding: See RFC 2045, section 6.8 */
return $this->_writeStream($fp, array(
'filter' => array(
'convert.base64-encode' => array(
'line-break-chars' => $this->getEOL(),
'line-length' => 76
)
)
));
case 'quoted-printable':
// PHP Bug 65776 - Must normalize the EOL characters.
stream_filter_register('horde_eol', 'Horde_Stream_Filter_Eol');
$stream = new Horde_Stream_Existing(array(
'stream' => $fp
));
$stream->stream = $this->_writeStream($stream->stream, array(
'filter' => array(
'horde_eol' => array('eol' => $stream->getEOL()
)
)));
/* Quoted-Printable Encoding: See RFC 2045, section 6.7 */
return $this->_writeStream($fp, array(
'filter' => array(
'convert.quoted-printable-encode' => array_filter(array(
'line-break-chars' => $stream->getEOL(),
'line-length' => 76
))
)
));
default:
$this->_temp['transferEncodeClose'] = false;
return $fp;
}
}
/**
* Set the MIME type of this part.
*
* @param string $type The MIME type to set (ex.: text/plain).
*/
public function setType($type)
{
/* RFC 2045: Any entity with unrecognized encoding must be treated
* as if it has a Content-Type of "application/octet-stream"
* regardless of what the Content-Type field actually says. */
if (!is_null($this->_transferEncoding)) {
$this->_headers['content-type']->setContentParamValue($type);
}
}
/**
* Get the full MIME Content-Type of this part.
*
* @param boolean $charset Append character set information to the end
* of the content type if this is a text/* part?
*`
* @return string The MIME type of this part.
*/
public function getType($charset = false)
{
$ct = $this->_headers['content-type'];
return $charset
? $ct->type_charset
: $ct->value;
}
/**
* If the subtype of a MIME part is unrecognized by an application, the
* default type should be used instead (See RFC 2046). This method
* returns the default subtype for a particular primary MIME type.
*
* @return string The default MIME type of this part (ex.: text/plain).
*/
public function getDefaultType()
{
switch ($this->getPrimaryType()) {
case 'text':
/* RFC 2046 (4.1.4): text parts default to text/plain. */
return 'text/plain';
case 'multipart':
/* RFC 2046 (5.1.3): multipart parts default to multipart/mixed. */
return 'multipart/mixed';
default:
/* RFC 2046 (4.2, 4.3, 4.4, 4.5.3, 5.2.4): all others default to
application/octet-stream. */
return 'application/octet-stream';
}
}
/**
* Get the primary type of this part.
*
* @return string The primary MIME type of this part.
*/
public function getPrimaryType()
{
return $this->_headers['content-type']->ptype;
}
/**
* Get the subtype of this part.
*
* @return string The MIME subtype of this part.
*/
public function getSubType()
{
return $this->_headers['content-type']->stype;
}
/**
* Set the character set of this part.
*
* @param string $charset The character set of this part.
*/
public function setCharset($charset)
{
$this->setContentTypeParameter('charset', $charset);
}
/**
* Get the character set to use for this part.
*
* @return string The character set of this part (lowercase). Returns
* null if there is no character set.
*/
public function getCharset()
{
return $this->getContentTypeParameter('charset')
?: (($this->getPrimaryType() === 'text') ? 'us-ascii' : null);
}
/**
* Set the character set to use when outputting MIME headers.
*
* @param string $charset The character set.
*/
public function setHeaderCharset($charset)
{
$this->_hdrCharset = $charset;
}
/**
* Get the character set to use when outputting MIME headers.
*
* @return string The character set. If no preferred character set has
* been set, returns null.
*/
public function getHeaderCharset()
{
return is_null($this->_hdrCharset)
? $this->getCharset()
: $this->_hdrCharset;
}
/**
* Set the language(s) of this part.
*
* @param mixed $lang A language string, or an array of language
* strings.
*/
public function setLanguage($lang)
{
$this->_headers->addHeaderOb(
new Horde_Mime_Headers_ContentLanguage('', $lang)
);
}
/**
* Get the language(s) of this part.
*
* @param array The list of languages.
*/
public function getLanguage()
{
return $this->_headers['content-language']->langs;
}
/**
* Set the content duration of the data contained in this part (see RFC
* 3803).
*
* @param integer $duration The duration of the data, in seconds. If
* null, clears the duration information.
*/
public function setDuration($duration)
{
if (is_null($duration)) {
unset($this->_headers['content-duration']);
} else {
if (!($hdr = $this->_headers['content-duration'])) {
$hdr = new Horde_Mime_Headers_Element_Single(
'Content-Duration',
''
);
$this->_headers->addHeaderOb($hdr);
}
$hdr->setValue($duration);
}
}
/**
* Get the content duration of the data contained in this part (see RFC
* 3803).
*
* @return integer The duration of the data, in seconds. Returns null if
* there is no duration information.
*/
public function getDuration()
{
return ($hdr = $this->_headers['content-duration'])
? intval($hdr->value)
: null;
}
/**
* Set the description of this part.
*
* @param string $description The description of this part. If null,
* deletes the description (@since 2.8.0).
*/
public function setDescription($description)
{
if (is_null($description)) {
unset($this->_headers['content-description']);
} else {
if (!($hdr = $this->_headers['content-description'])) {
$hdr = new Horde_Mime_Headers_ContentDescription(null, '');
$this->_headers->addHeaderOb($hdr);
}
$hdr->setValue($description);
}
}
/**
* Get the description of this part.
*
* @param boolean $default If the description parameter doesn't exist,
* should we use the name of the part?
*
* @return string The description of this part.
*/
public function getDescription($default = false)
{
if (($ob = $this->_headers['content-description']) &&
strlen($ob->value)) {
return $ob->value;
}
return $default
? $this->getName()
: '';
}
/**
* Set the transfer encoding to use for this part.
*
* Only needed in the following circumstances:
* 1.) Indicate what the transfer encoding is if the data has not yet been
* set in the object (can only be set if there presently are not
* any contents).
* 2.) Force the encoding to a certain type on a toString() call (if
* 'send' is true).
*
* @param string $encoding The transfer encoding to use.
* @param array $options Additional options:
* - send: (boolean) If true, use $encoding as the sending encoding.
* DEFAULT: $encoding is used to change the base encoding.
*/
public function setTransferEncoding($encoding, $options = array())
{
if (empty($encoding) ||
(empty($options['send']) && !empty($this->_contents))) {
return;
}
switch ($encoding = Horde_String::lower($encoding)) {
case '7bit':
case '8bit':
case 'base64':
case 'binary':
case 'quoted-printable':
// Non-RFC types, but old mailers may still use
case 'uuencode':
case 'x-uuencode':
case 'x-uue':
if (empty($options['send'])) {
$this->_transferEncoding = $encoding;
} else {
$this->_temp['sendEncoding'] = $encoding;
}
break;
default:
if (empty($options['send'])) {
/* RFC 2045: Any entity with unrecognized encoding must be
* treated as if it has a Content-Type of
* "application/octet-stream" regardless of what the
* Content-Type field actually says. */
$this->setType('application/octet-stream');
$this->_transferEncoding = null;
}
break;
}
}
/**
* Get a list of all MIME subparts.
*
* @return array An array of the Horde_Mime_Part subparts.
*/
public function getParts()
{
return $this->_parts;
}
/**
* Add/remove a content type parameter to this part.
*
* @param string $label The content-type parameter label.
* @param string $data The content-type parameter data. If null, removes
* the parameter (@since 2.8.0).
*/
public function setContentTypeParameter($label, $data)
{
$ct = $this->_headers['content-type'];
if (is_null($data)) {
unset($ct[$label]);
} elseif (strlen($data)) {
$ct[$label] = $data;
}
}
/**
* Get a content type parameter from this part.
*
* @param string $label The content type parameter label.
*
* @return string The data requested.
* Returns null if $label is not set.
*/
public function getContentTypeParameter($label)
{
$ct = $this->_headers['content-type'];
return $ct[$label];
}
/**
* Get all parameters from the Content-Type header.
*
* @return array An array of all the parameters
* Returns the empty array if no parameters set.
*/
public function getAllContentTypeParameters()
{
return $this->_headers['content-type']->params;
}
/**
* Sets a new string to use for EOLs.
*
* @param string $eol The string to use for EOLs.
*/
public function setEOL($eol)
{
$this->_eol = $eol;
}
/**
* Get the string to use for EOLs.
*
* @return string The string to use for EOLs.
*/
public function getEOL()
{
return $this->_eol;
}
/**
* Returns a Horde_Mime_Header object containing all MIME headers needed
* for the part.
*
* @param array $options Additional options:
* - encode: (integer) A mask of allowable encodings.
* DEFAULT: Auto-determined
* - headers: (Horde_Mime_Headers) The object to add the MIME headers
* to.
* DEFAULT: Add headers to a new object
*
* @return Horde_Mime_Headers A Horde_Mime_Headers object.
*/
public function addMimeHeaders($options = array())
{
if (empty($options['headers'])) {
$headers = new Horde_Mime_Headers();
} else {
$headers = $options['headers'];
$headers->removeHeader('Content-Disposition');
$headers->removeHeader('Content-Transfer-Encoding');
}
/* Add the mandatory Content-Type header. */
$ct = $this->_headers['content-type'];
$headers->addHeaderOb($ct);
/* Add the language(s), if set. (RFC 3282 [2]) */
if ($hdr = $this->_headers['content-language']) {
$headers->addHeaderOb($hdr);
}
/* Get the description, if any. */
if ($hdr = $this->_headers['content-description']) {
$headers->addHeaderOb($hdr);
}
/* Set the duration, if it exists. (RFC 3803) */
if ($hdr = $this->_headers['content-duration']) {
$headers->addHeaderOb($hdr);
}
/* Per RFC 2046[4], this MUST appear in the base message headers. */
if ($this->_status & self::STATUS_BASEPART) {
$headers->addHeaderOb(Horde_Mime_Headers_MimeVersion::create());
}
/* message/* parts require no additional header information. */
if ($ct->ptype === 'message') {
return $headers;
}
/* RFC 2183 [2] indicates that default is no requested disposition -
* the receiving MUA is responsible for display choice. */
$cd = $this->_headers['content-disposition'];
if (!$cd->isDefault()) {
$headers->addHeaderOb($cd);
}
/* Add transfer encoding information. RFC 2045 [6.1] indicates that
* default is 7bit. No need to send the header in this case. */
$cte = new Horde_Mime_Headers_ContentTransferEncoding(
null,
$this->_getTransferEncoding(
empty($options['encode']) ? null : $options['encode']
)
);
if (!$cte->isDefault()) {
$headers->addHeaderOb($cte);
}
/* Add content ID information. */
if ($hdr = $this->_headers['content-id']) {
$headers->addHeaderOb($hdr);
}
return $headers;
}
/**
* Return the entire part in MIME format.
*
* @param array $options Additional options:
* - canonical: (boolean) Returns the encoded part in strict RFC 822 &
* 2045 output - namely, all newlines end with the
* canonical <CR><LF> sequence.
* DEFAULT: false
* - defserver: (string) The default server to use when creating the
* header string.
* DEFAULT: none
* - encode: (integer) A mask of allowable encodings.
* DEFAULT: self::ENCODE_7BIT
* - headers: (mixed) Include the MIME headers? If true, create a new
* headers object. If a Horde_Mime_Headers object, add MIME
* headers to this object. If a string, use the string
* verbatim.
* DEFAULT: true
* - id: (string) Return only this MIME ID part.
* DEFAULT: Returns the base part.
* - stream: (boolean) Return a stream resource.
* DEFAULT: false
*
* @return mixed The MIME string (returned as a resource if $stream is
* true).
*/
public function toString($options = array())
{
$eol = $this->getEOL();
$isbase = true;
$oldbaseptr = null;
$parts = $parts_close = array();
if (isset($options['id'])) {
$id = $options['id'];
if (!($part = $this[$id])) {
return $part;
}
unset($options['id']);
$contents = $part->toString($options);
$prev_id = Horde_Mime::mimeIdArithmetic($id, 'up', array('norfc822' => true));
$prev_part = ($prev_id == $this->getMimeId())
? $this
: $this[$prev_id];
if (!$prev_part) {
return $contents;
}
$boundary = trim($this->getContentTypeParameter('boundary'), '"');
$parts = array(
$eol . '--' . $boundary . $eol,
$contents
);
if (!isset($this[Horde_Mime::mimeIdArithmetic($id, 'next')])) {
$parts[] = $eol . '--' . $boundary . '--' . $eol;
}
} else {
if ($isbase = empty($options['_notbase'])) {
$headers = !empty($options['headers'])
? $options['headers']
: false;
if (empty($options['encode'])) {
$options['encode'] = null;
}
if (empty($options['defserver'])) {
$options['defserver'] = null;
}
$options['headers'] = true;
$options['_notbase'] = true;
} else {
$headers = true;
$oldbaseptr = &$options['_baseptr'];
}
$this->_temp['toString'] = '';
$options['_baseptr'] = &$this->_temp['toString'];
/* Any information about a message is embedded in the message
* contents themself. Simply output the contents of the part
* directly and return. */
$ptype = $this->getPrimaryType();
if ($ptype == 'message') {
$parts[] = $this->_contents;
} else {
if (!empty($this->_contents)) {
$encoding = $this->_getTransferEncoding($options['encode']);
switch ($encoding) {
case '8bit':
if (empty($options['_baseptr'])) {
$options['_baseptr'] = '8bit';
}
break;
case 'binary':
$options['_baseptr'] = 'binary';
break;
}
$parts[] = $this->_transferEncode($this->_contents, $encoding);
/* If not using $this->_contents, we can close the stream
* when finished. */
if ($this->_temp['transferEncodeClose']) {
$parts_close[] = end($parts);
}
}
/* Deal with multipart messages. */
if ($ptype == 'multipart') {
if (empty($this->_contents)) {
$parts[] = 'This message is in MIME format.' . $eol;
}
$boundary = trim($this->getContentTypeParameter('boundary'), '"');
/* If base part is multipart/digest, children should not
* have content-type (automatically treated as
* message/rfc822; RFC 2046 [5.1.5]). */
if ($this->getSubType() === 'digest') {
$options['is_digest'] = true;
}
foreach ($this as $part) {
$parts[] = $eol . '--' . $boundary . $eol;
$tmp = $part->toString($options);
if ($part->getEOL() != $eol) {
$tmp = $this->replaceEOL($tmp, $eol, !empty($options['stream']));
}
if (!empty($options['stream'])) {
$parts_close[] = $tmp;
}
$parts[] = $tmp;
}
$parts[] = $eol . '--' . $boundary . '--' . $eol;
}
}
if (is_string($headers)) {
array_unshift($parts, $headers);
} elseif ($headers) {
$hdr_ob = $this->addMimeHeaders(array(
'encode' => $options['encode'],
'headers' => ($headers === true) ? null : $headers
));
if (!$isbase && !empty($options['is_digest'])) {
unset($hdr_ob['content-type']);
}
if (!empty($this->_temp['toString'])) {
$hdr_ob->addHeader(
'Content-Transfer-Encoding',
$this->_temp['toString']
);
}
array_unshift($parts, $hdr_ob->toString(array(
'canonical' => ($eol == self::RFC_EOL),
'charset' => $this->getHeaderCharset(),
'defserver' => $options['defserver']
)));
}
}
$newfp = $this->_writeStream($parts);
array_map('fclose', $parts_close);
if (!is_null($oldbaseptr)) {
switch ($this->_temp['toString']) {
case '8bit':
if (empty($oldbaseptr)) {
$oldbaseptr = '8bit';
}
break;
case 'binary':
$oldbaseptr = 'binary';
break;
}
}
if ($isbase && !empty($options['canonical'])) {
return $this->replaceEOL($newfp, self::RFC_EOL, !empty($options['stream']));
}
return empty($options['stream'])
? $this->_readStream($newfp)
: $newfp;
}
/**
* Get the transfer encoding for the part based on the user requested
* transfer encoding and the current contents of the part.
*
* @param integer $encode A mask of allowable encodings.
*
* @return string The transfer-encoding of this part.
*/
protected function _getTransferEncoding($encode = self::ENCODE_7BIT)
{
if (!empty($this->_temp['sendEncoding'])) {
return $this->_temp['sendEncoding'];
} elseif (!empty($this->_temp['sendTransferEncoding'][$encode])) {
return $this->_temp['sendTransferEncoding'][$encode];
}
if (empty($this->_contents)) {
$encoding = '7bit';
} else {
switch ($this->getPrimaryType()) {
case 'message':
case 'multipart':
/* RFC 2046 [5.2.1] - message/rfc822 messages only allow 7bit,
* 8bit, and binary encodings. If the current encoding is
* either base64 or q-p, switch it to 8bit instead.
* RFC 2046 [5.2.2, 5.2.3, 5.2.4] - All other messages
* only allow 7bit encodings.
*
* TODO: What if message contains 8bit characters and we are
* in strict 7bit mode? Not sure there is anything we can do
* in that situation, especially for message/rfc822 parts.
*
* These encoding will be figured out later (via toString()).
* They are limited to 7bit, 8bit, and binary. Default to
* '7bit' per RFCs. */
$default_8bit = 'base64';
$encoding = '7bit';
break;
case 'text':
$default_8bit = 'quoted-printable';
$encoding = '7bit';
break;
default:
$default_8bit = 'base64';
/* If transfer encoding has changed from the default, use that
* value. */
$encoding = ($this->_transferEncoding == self::DEFAULT_ENCODING)
? 'base64'
: $this->_transferEncoding;
break;
}
switch ($encoding) {
case 'base64':
case 'binary':
break;
default:
$encoding = $this->_scanStream($this->_contents);
break;
}
switch ($encoding) {
case 'base64':
case 'binary':
/* If the text is longer than 998 characters between
* linebreaks, use quoted-printable encoding to ensure the
* text will not be chopped (i.e. by sendmail if being
* sent as mail text). */
$encoding = $default_8bit;
break;
case '8bit':
$encoding = (($encode & self::ENCODE_8BIT) || ($encode & self::ENCODE_BINARY))
? '8bit'
: $default_8bit;
break;
}
}
$this->_temp['sendTransferEncoding'][$encode] = $encoding;
return $encoding;
}
/**
* Replace newlines in this part's contents with those specified by either
* the given newline sequence or the part's current EOL setting.
*
* @param mixed $text The text to replace. Either a string or a
* stream resource. If a stream, and returning
* a string, will close the stream when done.
* @param string $eol The EOL sequence to use. If not present, uses
* the part's current EOL setting.
* @param boolean $stream If true, returns a stream resource.
*
* @return string The text with the newlines replaced by the desired
* newline sequence (returned as a stream resource if
* $stream is true).
*/
public function replaceEOL($text, $eol = null, $stream = false)
{
if (is_null($eol)) {
$eol = $this->getEOL();
}
stream_filter_register('horde_eol', 'Horde_Stream_Filter_Eol');
$fp = $this->_writeStream($text, array(
'filter' => array(
'horde_eol' => array('eol' => $eol)
)
));
return $stream ? $fp : $this->_readStream($fp, true);
}
/**
* Determine the size of this MIME part and its child members.
*
* @todo Remove $approx parameter.
*
* @param boolean $approx If true, determines an approximate size for
* parts consisting of base64 encoded data.
*
* @return integer Size of the part, in bytes.
*/
public function getBytes($approx = false)
{
if ($this->getPrimaryType() == 'multipart') {
if (isset($this->_bytes)) {
return $this->_bytes;
}
$bytes = 0;
foreach ($this as $part) {
$bytes += $part->getBytes($approx);
}
return $bytes;
}
if ($this->_contents) {
fseek($this->_contents, 0, SEEK_END);
$bytes = ftell($this->_contents);
} else {
$bytes = $this->_bytes;
/* Base64 transfer encoding is approx. 33% larger than original
* data size (RFC 2045 [6.8]). */
if ($approx && ($this->_transferEncoding == 'base64')) {
$bytes *= 0.75;
}
}
return intval($bytes);
}
/**
* Explicitly set the size (in bytes) of this part. This value will only
* be returned (via getBytes()) if there are no contents currently set.
*
* This function is useful for setting the size of the part when the
* contents of the part are not fully loaded (i.e. creating a
* Horde_Mime_Part object from IMAP header information without loading the
* data of the part).
*
* @param integer $bytes The size of this part in bytes.
*/
public function setBytes($bytes)
{
/* Consider 'size' disposition parameter to be the canonical size.
* Only set bytes if that value doesn't exist. */
if (!$this->getDispositionParameter('size')) {
$this->setDispositionParameter('size', $bytes);
}
}
/**
* Output the size of this MIME part in KB.
*
* @todo Remove $approx parameter.
*
* @param boolean $approx If true, determines an approximate size for
* parts consisting of base64 encoded data.
*
* @return string Size of the part in KB.
*/
public function getSize($approx = false)
{
if (!($bytes = $this->getBytes($approx))) {
return 0;
}
$localeinfo = Horde_Nls::getLocaleInfo();
// TODO: Workaround broken number_format() prior to PHP 5.4.0.
return str_replace(
array('X', 'Y'),
array($localeinfo['decimal_point'], $localeinfo['thousands_sep']),
number_format(ceil($bytes / 1024), 0, 'X', 'Y')
);
}
/**
* Sets the Content-ID header for this part.
*
* @param string $cid Use this CID (if not already set). Else, generate
* a random CID.
*
* @return string The Content-ID for this part.
*/
public function setContentId($cid = null)
{
if (!is_null($id = $this->getContentId())) {
return $id;
}
$this->_headers->addHeaderOb(
is_null($cid)
? Horde_Mime_Headers_ContentId::create()
: new Horde_Mime_Headers_ContentId(null, $cid)
);
return $this->getContentId();
}
/**
* Returns the Content-ID for this part.
*
* @return string The Content-ID for this part (null if not set).
*/
public function getContentId()
{
return ($hdr = $this->_headers['content-id'])
? trim($hdr->value, '<>')
: null;
}
/**
* Alter the MIME ID of this part.
*
* @param string $mimeid The MIME ID.
*/
public function setMimeId($mimeid)
{
$this->_mimeid = $mimeid;
}
/**
* Returns the MIME ID of this part.
*
* @return string The MIME ID.
*/
public function getMimeId()
{
return $this->_mimeid;
}
/**
* Build the MIME IDs for this part and all subparts.
*
* @param string $id The ID of this part.
* @param boolean $rfc822 Is this a message/rfc822 part?
*/
public function buildMimeIds($id = null, $rfc822 = false)
{
$this->_status &= ~self::STATUS_REINDEX;
if (is_null($id)) {
$rfc822 = true;
$id = '';
}
if ($rfc822) {
if (empty($this->_parts) &&
($this->getPrimaryType() != 'multipart')) {
$this->setMimeId($id . '1');
} else {
if (empty($id) && ($this->getType() == 'message/rfc822')) {
$this->setMimeId('1.0');
} else {
$this->setMimeId($id . '0');
}
$i = 1;
foreach ($this as $val) {
$val->buildMimeIds($id . ($i++));
}
}
} else {
$this->setMimeId($id);
$id = $id
? ((substr($id, -2) === '.0') ? substr($id, 0, -1) : ($id . '.'))
: '';
if (count($this)) {
if ($this->getType() == 'message/rfc822') {
$this->rewind();
$this->current()->buildMimeIds($id, true);
} else {
$i = 1;
foreach ($this as $val) {
$val->buildMimeIds($id . ($i++));
}
}
}
}
}
/**
* Is this the base MIME part?
*
* @param boolean $base True if this is the base MIME part.
*/
public function isBasePart($base)
{
if (empty($base)) {
$this->_status &= ~self::STATUS_BASEPART;
} else {
$this->_status |= self::STATUS_BASEPART;
}
}
/**
* Determines if this MIME part is an attachment for display purposes.
*
* @since Horde_Mime 2.10.0
*
* @return boolean True if this part should be considered an attachment.
*/
public function isAttachment()
{
$type = $this->getType();
switch ($type) {
case 'application/ms-tnef':
case 'application/pgp-keys':
case 'application/vnd.ms-tnef':
return false;
}
if ($this->parent) {
switch ($this->parent->getType()) {
case 'multipart/encrypted':
switch ($type) {
case 'application/octet-stream':
return false;
}
break;
case 'multipart/signed':
switch ($type) {
case 'application/pgp-signature':
case 'application/pkcs7-signature':
case 'application/x-pkcs7-signature':
return false;
}
break;
}
}
switch ($this->getDisposition()) {
case 'attachment':
return true;
}
switch ($this->getPrimaryType()) {
case 'application':
if (strlen($this->getName())) {
return true;
}
break;
case 'audio':
case 'video':
return true;
case 'multipart':
return false;
}
return false;
}
/**
* Set a piece of metadata on this object.
*
* @param string $key The metadata key.
* @param mixed $data The metadata. If null, clears the key.
*/
public function setMetadata($key, $data = null)
{
if (is_null($data)) {
unset($this->_metadata[$key]);
} else {
$this->_metadata[$key] = $data;
}
}
/**
* Retrieves metadata from this object.
*
* @param string $key The metadata key.
*
* @return mixed The metadata, or null if it doesn't exist.
*/
public function getMetadata($key)
{
return isset($this->_metadata[$key])
? $this->_metadata[$key]
: null;
}
/**
* Sends this message.
*
* @param string $email The address list to send to.
* @param Horde_Mime_Headers $headers The Horde_Mime_Headers object
* holding this message's headers.
* @param Horde_Mail_Transport $mailer A Horde_Mail_Transport object.
* @param array $opts Additional options:
* <pre>
* - broken_rfc2231: (boolean) Attempt to work around non-RFC
* 2231-compliant MUAs by generating both a RFC
* 2047-like parameter name and also the correct RFC
* 2231 parameter (@since 2.5.0).
* DEFAULT: false
* - encode: (integer) The encoding to use. A mask of self::ENCODE_*
* values.
* DEFAULT: Auto-determined based on transport driver.
* </pre>
*
* @throws Horde_Mime_Exception
* @throws InvalidArgumentException
*/
public function send($email, $headers, Horde_Mail_Transport $mailer,
array $opts = array())
{
$old_status = $this->_status;
$this->isBasePart(true);
/* Does the SMTP backend support 8BITMIME (RFC 1652)? */
$canonical = true;
$encode = self::ENCODE_7BIT;
if (isset($opts['encode'])) {
/* Always allow 7bit encoding. */
$encode |= $opts['encode'];
} elseif ($mailer instanceof Horde_Mail_Transport_Smtp) {
try {
$smtp_ext = $mailer->getSMTPObject()->getServiceExtensions();
if (isset($smtp_ext['8BITMIME'])) {
$encode |= self::ENCODE_8BIT;
}
} catch (Horde_Mail_Exception $e) {}
$canonical = false;
} elseif ($mailer instanceof Horde_Mail_Transport_Smtphorde) {
try {
if ($mailer->getSMTPObject()->data_8bit) {
$encode |= self::ENCODE_8BIT;
}
} catch (Horde_Mail_Exception $e) {}
$canonical = false;
}
$msg = $this->toString(array(
'canonical' => $canonical,
'encode' => $encode,
'headers' => false,
'stream' => true
));
/* Add MIME Headers if they don't already exist. */
if (!isset($headers['MIME-Version'])) {
$headers = $this->addMimeHeaders(array(
'encode' => $encode,
'headers' => $headers
));
}
if (!empty($this->_temp['toString'])) {
$headers->addHeader(
'Content-Transfer-Encoding',
$this->_temp['toString']
);
switch ($this->_temp['toString']) {
case '8bit':
if ($mailer instanceof Horde_Mail_Transport_Smtp) {
$mailer->addServiceExtensionParameter('BODY', '8BITMIME');
}
break;
}
}
$this->_status = $old_status;
$rfc822 = new Horde_Mail_Rfc822();
try {
$mailer->send($rfc822->parseAddressList($email)->writeAddress(array(
'encode' => $this->getHeaderCharset() ?: true,
'idn' => true
)), $headers->toArray(array(
'broken_rfc2231' => !empty($opts['broken_rfc2231']),
'canonical' => $canonical,
'charset' => $this->getHeaderCharset()
)), $msg);
} catch (InvalidArgumentException $e) {
// Try to rebuild the part in case it was due to
// an invalid line length in a rfc822/message attachment.
if ($this->_failed) {
throw $e;
}
$this->_failed = true;
$this->_sanityCheckRfc822Attachments();
try {
$this->send($email, $headers, $mailer, $opts);
} catch (Horde_Mail_Exception $e) {
throw new Horde_Mime_Exception($e);
}
} catch (Horde_Mail_Exception $e) {
throw new Horde_Mime_Exception($e);
}
}
/**
* Finds the main "body" text part (if any) in a message.
* "Body" data is the first text part under this part.
*
* @param string $subtype Specifically search for this subtype.
*
* @return mixed The MIME ID of the main body part, or null if a body
* part is not found.
*/
public function findBody($subtype = null)
{
$this->buildMimeIds();
foreach ($this->partIterator() as $val) {
$id = $val->getMimeId();
if (($val->getPrimaryType() == 'text') &&
((intval($id) === 1) || !$this->getMimeId()) &&
(is_null($subtype) || ($val->getSubType() == $subtype)) &&
($val->getDisposition() !== 'attachment')) {
return $id;
}
}
return null;
}
/**
* Returns the recursive iterator needed to iterate through this part.
*
* @since 2.8.0
*
* @param boolean $current Include the current part as the base?
*
* @return Iterator Recursive iterator.
*/
public function partIterator($current = true)
{
$this->_reindex(true);
return new Horde_Mime_Part_Iterator($this, $current);
}
/**
* Returns a subpart by index.
*
* @return Horde_Mime_Part Part, or null if not found.
*/
public function getPartByIndex($index)
{
if (!isset($this->_parts[$index])) {
return null;
}
$part = $this->_parts[$index];
$part->parent = $this;
return $part;
}
/**
* Reindexes the MIME IDs, if necessary.
*
* @param boolean $force Reindex if the current part doesn't have an ID.
*/
protected function _reindex($force = false)
{
$id = $this->getMimeId();
if (($this->_status & self::STATUS_REINDEX) ||
($force && is_null($id))) {
$this->buildMimeIds(
is_null($id)
? (($this->getPrimaryType() === 'multipart') ? '0' : '1')
: $id
);
}
}
/**
* Write data to a stream.
*
* @param array $data The data to write. Either a stream resource or
* a string.
* @param array $options Additional options:
* - error: (boolean) Catch errors when writing to the stream. Throw an
* ErrorException if an error is found.
* DEFAULT: false
* - filter: (array) Filter(s) to apply to the string. Keys are the
* filter names, values are filter params.
* - fp: (resource) Use this stream instead of creating a new one.
*
* @return resource The stream resource.
* @throws ErrorException
*/
protected function _writeStream($data, $options = array())
{
if (empty($options['fp'])) {
$fp = fopen('php://temp/maxmemory:' . self::$memoryLimit, 'r+');
} else {
$fp = $options['fp'];
fseek($fp, 0, SEEK_END);
}
if (!is_array($data)) {
$data = array($data);
}
$append_filter = array();
if (!empty($options['filter'])) {
foreach ($options['filter'] as $key => $val) {
$append_filter[] = stream_filter_append($fp, $key, STREAM_FILTER_WRITE, $val);
}
}
if (!empty($options['error'])) {
set_error_handler(function($errno, $errstr) {
throw new ErrorException($errstr, $errno);
});
$error = null;
}
try {
foreach ($data as $d) {
if (is_resource($d)) {
rewind($d);
while (!feof($d)) {
fwrite($fp, fread($d, 8192));
}
} elseif (is_string($d)) {
$len = strlen($d);
$i = 0;
while ($i < $len) {
fwrite($fp, substr($d, $i, 8192));
$i += 8192;
}
}
}
} catch (ErrorException $e) {
$error = $e;
}
foreach ($append_filter as $val) {
stream_filter_remove($val);
}
if (!empty($options['error'])) {
restore_error_handler();
if ($error) {
throw $error;
}
}
return $fp;
}
/**
* Read data from a stream.
*
* @param resource $fp An active stream.
* @param boolean $close Close the stream when done reading?
*
* @return string The data from the stream.
*/
protected function _readStream($fp, $close = false)
{
$out = '';
if (!is_resource($fp)) {
return $out;
}
rewind($fp);
while (!feof($fp)) {
$out .= fread($fp, 8192);
}
if ($close) {
fclose($fp);
}
return $out;
}
/**
* Scans a stream for content type.
*
* @param resource $fp A stream resource.
*
* @return mixed Either 'binary', '8bit', or false.
*/
protected function _scanStream($fp)
{
rewind($fp);
stream_filter_register(
'horde_mime_scan_stream',
'Horde_Mime_Filter_Encoding'
);
$filter_params = new stdClass;
$filter = stream_filter_append(
$fp,
'horde_mime_scan_stream',
STREAM_FILTER_READ,
$filter_params
);
while (!feof($fp)) {
fread($fp, 8192);
}
stream_filter_remove($filter);
return $filter_params->body;
}
/* Static methods. */
/**
* Attempts to build a Horde_Mime_Part object from message text.
*
* @param string $text The text of the MIME message.
* @param array $opts Additional options:
* - forcemime: (boolean) If true, the message data is assumed to be
* MIME data. If not, a MIME-Version header must exist (RFC
* 2045 [4]) to be parsed as a MIME message.
* DEFAULT: false
* - level: (integer) Current nesting level of the MIME data.
* DEFAULT: 0
* - no_body: (boolean) If true, don't set body contents of parts (since
* 2.2.0).
* DEFAULT: false
*
* @return Horde_Mime_Part A MIME Part object.
* @throws Horde_Mime_Exception
*/
public static function parseMessage($text, array $opts = array())
{
/* Mini-hack to get a blank Horde_Mime part so we can call
* replaceEOL(). Convert to EOL, since that is the expected EOL for
* use internally within a Horde_Mime_Part object. */
$part = new Horde_Mime_Part();
$rawtext = $part->replaceEOL($text, self::EOL);
/* Find the header. */
$hdr_pos = self::_findHeader($rawtext, self::EOL);
unset($opts['ctype']);
$ob = self::_getStructure(substr($rawtext, 0, $hdr_pos), substr($rawtext, $hdr_pos + 2), $opts);
$ob->buildMimeIds();
return $ob;
}
/**
* Creates a MIME object from the text of one part of a MIME message.
*
* @param string $header The header text.
* @param string $body The body text.
* @param array $opts Additional options:
* <pre>
* - ctype: (string) The default content-type.
* - forcemime: (boolean) If true, the message data is assumed to be
* MIME data. If not, a MIME-Version header must exist to
* be parsed as a MIME message.
* - level: (integer) Current nesting level.
* - no_body: (boolean) If true, don't set body contents of parts.
* </pre>
*
* @return Horde_Mime_Part The MIME part object.
*/
protected static function _getStructure($header, $body,
array $opts = array())
{
$opts = array_merge(array(
'ctype' => 'text/plain',
'forcemime' => false,
'level' => 0,
'no_body' => false
), $opts);
/* Parse headers text into a Horde_Mime_Headers object. */
$hdrs = Horde_Mime_Headers::parseHeaders($header);
$ob = new Horde_Mime_Part();
/* This is not a MIME message. */
if (!$opts['forcemime'] && !isset($hdrs['MIME-Version'])) {
$ob->setType('text/plain');
if ($len = strlen($body)) {
if ($opts['no_body']) {
$ob->setBytes($len);
} else {
$ob->setContents($body);
}
}
return $ob;
}
/* Content type. */
if ($tmp = $hdrs['Content-Type']) {
$ob->setType($tmp->value);
foreach ($tmp->params as $key => $val) {
$ob->setContentTypeParameter($key, $val);
}
} else {
$ob->setType($opts['ctype']);
}
/* Content transfer encoding. */
if ($tmp = $hdrs['Content-Transfer-Encoding']) {
$ob->setTransferEncoding(strval($tmp));
}
/* Content-Description. */
if ($tmp = $hdrs['Content-Description']) {
$ob->setDescription(strval($tmp));
}
/* Content-Disposition. */
if ($tmp = $hdrs['Content-Disposition']) {
$ob->setDisposition($tmp->value);
foreach ($tmp->params as $key => $val) {
$ob->setDispositionParameter($key, $val);
}
}
/* Content-Duration */
if ($tmp = $hdrs['Content-Duration']) {
$ob->setDuration(strval($tmp));
}
/* Content-ID. */
if ($tmp = $hdrs['Content-Id']) {
$ob->setContentId(strval($tmp));
}
if (($len = strlen($body)) && ($ob->getPrimaryType() != 'multipart')) {
if ($opts['no_body']) {
$ob->setBytes($len);
} else {
$ob->setContents($body);
}
}
if (++$opts['level'] >= self::NESTING_LIMIT) {
return $ob;
}
/* Process subparts. */
switch ($ob->getPrimaryType()) {
case 'message':
if ($ob->getSubType() == 'rfc822') {
$ob[] = self::parseMessage($body, array(
'forcemime' => true,
'no_body' => $opts['no_body']
));
}
break;
case 'multipart':
$boundary = $ob->getContentTypeParameter('boundary');
if (!is_null($boundary)) {
foreach (self::_findBoundary($body, 0, $boundary) as $val) {
if (!isset($val['length'])) {
break;
}
$subpart = substr($body, $val['start'], $val['length']);
$hdr_pos = self::_findHeader($subpart, self::EOL);
$ob[] = self::_getStructure(
substr($subpart, 0, $hdr_pos),
substr($subpart, $hdr_pos + 2),
array(
'ctype' => ($ob->getSubType() == 'digest') ? 'message/rfc822' : 'text/plain',
'forcemime' => true,
'level' => $opts['level'],
'no_body' => $opts['no_body']
)
);
}
}
break;
}
return $ob;
}
/**
* Attempts to obtain the raw text of a MIME part.
*
* @param mixed $text The full text of the MIME message. The text is
* assumed to be MIME data (no MIME-Version checking
* is performed). It can be either a stream or a
* string.
* @param string $type Either 'header' or 'body'.
* @param string $id The MIME ID.
*
* @return string The raw text.
* @throws Horde_Mime_Exception
*/
public static function getRawPartText($text, $type, $id)
{
/* Mini-hack to get a blank Horde_Mime part so we can call
* replaceEOL(). From an API perspective, getRawPartText() should be
* static since it is not working on MIME part data. */
$part = new Horde_Mime_Part();
$rawtext = $part->replaceEOL($text, self::RFC_EOL);
/* We need to carry around the trailing "\n" because this is needed
* to correctly find the boundary string. */
$hdr_pos = self::_findHeader($rawtext, self::RFC_EOL);
$curr_pos = $hdr_pos + 3;
if ($id == 0) {
switch ($type) {
case 'body':
return substr($rawtext, $curr_pos + 1);
case 'header':
return trim(substr($rawtext, 0, $hdr_pos));
}
}
$hdr_ob = Horde_Mime_Headers::parseHeaders(trim(substr($rawtext, 0, $hdr_pos)));
/* If this is a message/rfc822, pass the body into the next loop.
* Don't decrement the ID here. */
if (($ct = $hdr_ob['Content-Type']) && ($ct == 'message/rfc822')) {
return self::getRawPartText(
substr($rawtext, $curr_pos + 1),
$type,
$id
);
}
$base_pos = strpos($id, '.');
$orig_id = $id;
if ($base_pos !== false) {
$id = substr($id, $base_pos + 1);
$base_pos = substr($orig_id, 0, $base_pos);
} else {
$base_pos = $id;
$id = 0;
}
if ($ct && !isset($ct->params['boundary'])) {
if ($orig_id == '1') {
return substr($rawtext, $curr_pos + 1);
}
throw new Horde_Mime_Exception('Could not find MIME part.');
}
$b_find = self::_findBoundary(
$rawtext,
$curr_pos,
$ct->params['boundary'],
$base_pos
);
if (!isset($b_find[$base_pos])) {
throw new Horde_Mime_Exception('Could not find MIME part.');
}
return self::getRawPartText(
substr(
$rawtext,
$b_find[$base_pos]['start'],
$b_find[$base_pos]['length'] - 1
),
$type,
$id
);
}
/**
* Find the location of the end of the header text.
*
* @param string $text The text to search.
* @param string $eol The EOL string.
*
* @return integer Header position.
*/
protected static function _findHeader($text, $eol)
{
$hdr_pos = strpos($text, $eol . $eol);
return ($hdr_pos === false)
? strlen($text)
: $hdr_pos;
}
/**
* Find the location of the next boundary string.
*
* @param string $text The text to search.
* @param integer $pos The current position in $text.
* @param string $boundary The boundary string.
* @param integer $end If set, return after matching this many
* boundaries.
*
* @return array Keys are the boundary number, values are an array with
* two elements: 'start' and 'length'.
*/
protected static function _findBoundary($text, $pos, $boundary,
$end = null)
{
$i = 0;
$out = array();
$search = "--" . $boundary;
$search_len = strlen($search);
while (($pos = strpos($text, $search, $pos)) !== false) {
/* Boundary needs to appear at beginning of string or right after
* a LF. */
if (($pos != 0) && ($text[$pos - 1] != "\n")) {
continue;
}
if (isset($out[$i])) {
$out[$i]['length'] = $pos - $out[$i]['start'] - 1;
}
if (!is_null($end) && ($end == $i)) {
break;
}
$pos += $search_len;
if (isset($text[$pos])) {
switch ($text[$pos]) {
case "\r":
$pos += 2;
$out[++$i] = array('start' => $pos);
break;
case "\n":
$out[++$i] = array('start' => ++$pos);
break;
case '-':
return $out;
}
}
}
return $out;
}
/**
* Re-enocdes message/rfc822 parts in case there was e.g., some broken
* line length in the headers of the message in the part. Since we shouldn't
* alter the original message in any way, we simply reset cause the part to
* be encoded as base64 and sent as a application/octet part.
*/
protected function _sanityCheckRfc822Attachments()
{
if ($this->getType() == 'message/rfc822') {
$this->_reEncodeMessageAttachment($this);
return;
}
foreach ($this->getParts() as $part) {
if ($part->getType() == 'message/rfc822') {
$this->_reEncodeMessageAttachment($part);
}
}
return;
}
/**
* Rebuilds $part and forces it to be a base64 encoded
* application/octet-stream part.
*
* @param Horde_Mime_Part $part The MIME part.
*/
protected function _reEncodeMessageAttachment(Horde_Mime_Part $part)
{
$new_part = Horde_Mime_Part::parseMessage($part->getContents());
$part->setContents($new_part->getContents(array('stream' => true)), array('encoding' => self::ENCODE_BINARY));
$part->setTransferEncoding('base64', array('send' => true));
}
/* ArrayAccess methods. */
/**
*/
public function offsetExists($offset)
{
return ($this[$offset] !== null);
}
/**
*/
public function offsetGet($offset)
{
$this->_reindex();
if (strcmp($offset, $this->getMimeId()) === 0) {
$this->parent = null;
return $this;
}
foreach ($this->_parts as $val) {
if (strcmp($offset, $val->getMimeId()) === 0) {
$val->parent = $this;
return $val;
}
if ($found = $val[$offset]) {
return $found;
}
}
return null;
}
/**
*/
public function offsetSet($offset, $value)
{
if (is_null($offset)) {
$this->_parts[] = $value;
$this->_status |= self::STATUS_REINDEX;
} elseif ($part = $this[$offset]) {
if ($part->parent === $this) {
if (($k = array_search($part, $this->_parts, true)) !== false) {
$value->setMimeId($part->getMimeId());
$this->_parts[$k] = $value;
}
} else {
$this->parent[$offset] = $value;
}
}
}
/**
*/
public function offsetUnset($offset)
{
if ($part = $this[$offset]) {
if ($part->parent === $this) {
if (($k = array_search($part, $this->_parts, true)) !== false) {
unset($this->_parts[$k]);
$this->_parts = array_values($this->_parts);
}
} else {
unset($part->parent[$offset]);
}
$this->_status |= self::STATUS_REINDEX;
}
}
/* Countable methods. */
/**
* Returns the number of child message parts (doesn't include
* grandchildren or more remote ancestors).
*
* @return integer Number of message parts.
*/
public function count()
{
return count($this->_parts);
}
/* RecursiveIterator methods. */
/**
* @since 2.8.0
*/
public function current()
{
return (($key = $this->key()) === null)
? null
: $this->getPartByIndex($key);
}
/**
* @since 2.8.0
*/
public function key()
{
return (isset($this->_temp['iterate']) && isset($this->_parts[$this->_temp['iterate']]))
? $this->_temp['iterate']
: null;
}
/**
* @since 2.8.0
*/
public function next()
{
++$this->_temp['iterate'];
}
/**
* @since 2.8.0
*/
public function rewind()
{
$this->_reindex();
reset($this->_parts);
$this->_temp['iterate'] = key($this->_parts);
}
/**
* @since 2.8.0
*/
public function valid()
{
return ($this->key() !== null);
}
/**
* @since 2.8.0
*/
public function hasChildren()
{
return (($curr = $this->current()) && count($curr));
}
/**
* @since 2.8.0
*/
public function getChildren()
{
return $this->current();
}
/* Serializable methods. */
/**
* Serialization.
*
* @return string Serialized data.
*/
public function serialize()
{
$data = array(
// Serialized data ID.
self::VERSION,
$this->_bytes,
$this->_eol,
$this->_hdrCharset,
$this->_headers,
$this->_metadata,
$this->_mimeid,
$this->_parts,
$this->_status,
$this->_transferEncoding
);
if (!empty($this->_contents)) {
$data[] = $this->_readStream($this->_contents);
}
return serialize($data);
}
/**
* Unserialization.
*
* @param string $data Serialized data.
*
* @throws Exception
*/
public function unserialize($data)
{
$data = @unserialize($data);
if (!is_array($data) ||
!isset($data[0]) ||
($data[0] != self::VERSION)) {
switch ($data[0]) {
case 1:
$convert = new Horde_Mime_Part_Upgrade_V1($data);
$data = $convert->data;
break;
default:
$data = null;
break;
}
if (is_null($data)) {
throw new Exception('Cache version change');
}
}
$key = 0;
$this->_bytes = $data[++$key];
$this->_eol = $data[++$key];
$this->_hdrCharset = $data[++$key];
$this->_headers = $data[++$key];
$this->_metadata = $data[++$key];
$this->_mimeid = $data[++$key];
$this->_parts = $data[++$key];
$this->_status = $data[++$key];
$this->_transferEncoding = $data[++$key];
if (isset($data[++$key])) {
$this->setContents($data[$key]);
}
}
/* Deprecated elements. */
/**
* @deprecated
*/
const UNKNOWN = 'x-unknown';
/**
* @deprecated
*/
public static $encodingTypes = array(
'7bit', '8bit', 'base64', 'binary', 'quoted-printable',
// Non-RFC types, but old mailers may still use
'uuencode', 'x-uuencode', 'x-uue'
);
/**
* @deprecated
*/
public static $mimeTypes = array(
'text', 'multipart', 'message', 'application', 'audio', 'image',
'video', 'model'
);
/**
* @deprecated Use setContentTypeParameter with a null $data value.
*/
public function clearContentTypeParameter($label)
{
$this->setContentTypeParam($label, null);
}
/**
* @deprecated Use iterator instead.
*/
public function contentTypeMap($sort = true)
{
$map = array();
foreach ($this->partIterator() as $val) {
$map[$val->getMimeId()] = $val->getType();
}
return $map;
}
/**
* @deprecated Use array access instead.
*/
public function addPart($mime_part)
{
$this[] = $mime_part;
}
/**
* @deprecated Use array access instead.
*/
public function getPart($id)
{
return $this[$id];
}
/**
* @deprecated Use array access instead.
*/
public function alterPart($id, $mime_part)
{
$this[$id] = $mime_part;
}
/**
* @deprecated Use array access instead.
*/
public function removePart($id)
{
unset($this[$id]);
}
}