[4414] | 1 | <?php |
---|
| 2 | /** |
---|
| 3 | * The Mail_mimeDecode class is used to decode mail/mime messages |
---|
| 4 | * |
---|
| 5 | * This class will parse a raw mime email and return |
---|
| 6 | * the structure. Returned structure is similar to |
---|
| 7 | * that returned by imap_fetchstructure(). |
---|
| 8 | * |
---|
| 9 | * +----------------------------- IMPORTANT ------------------------------+ |
---|
| 10 | * | Usage of this class compared to native php extensions such as | |
---|
| 11 | * | mailparse or imap, is slow and may be feature deficient. If available| |
---|
| 12 | * | you are STRONGLY recommended to use the php extensions. | |
---|
| 13 | * +----------------------------------------------------------------------+ |
---|
| 14 | * |
---|
| 15 | * Compatible with PHP versions 4 and 5 |
---|
| 16 | * |
---|
| 17 | * LICENSE: This LICENSE is in the BSD license style. |
---|
| 18 | * Copyright (c) 2002-2003, Richard Heyes <richard@phpguru.org> |
---|
| 19 | * Copyright (c) 2003-2006, PEAR <pear-group@php.net> |
---|
| 20 | * All rights reserved. |
---|
| 21 | * |
---|
| 22 | * Redistribution and use in source and binary forms, with or |
---|
| 23 | * without modification, are permitted provided that the following |
---|
| 24 | * conditions are met: |
---|
| 25 | * |
---|
| 26 | * - Redistributions of source code must retain the above copyright |
---|
| 27 | * notice, this list of conditions and the following disclaimer. |
---|
| 28 | * - Redistributions in binary form must reproduce the above copyright |
---|
| 29 | * notice, this list of conditions and the following disclaimer in the |
---|
| 30 | * documentation and/or other materials provided with the distribution. |
---|
| 31 | * - Neither the name of the authors, nor the names of its contributors |
---|
| 32 | * may be used to endorse or promote products derived from this |
---|
| 33 | * software without specific prior written permission. |
---|
| 34 | * |
---|
| 35 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
---|
| 36 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
---|
| 37 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
---|
| 38 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
---|
| 39 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
---|
| 40 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
---|
| 41 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
---|
| 42 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
---|
| 43 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
---|
| 44 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
---|
| 45 | * THE POSSIBILITY OF SUCH DAMAGE. |
---|
| 46 | * |
---|
| 47 | * @category Mail |
---|
| 48 | * @package Mail_Mime |
---|
| 49 | * @author Richard Heyes <richard@phpguru.org> |
---|
| 50 | * @author George Schlossnagle <george@omniti.com> |
---|
| 51 | * @author Cipriano Groenendal <cipri@php.net> |
---|
| 52 | * @author Sean Coates <sean@php.net> |
---|
| 53 | * @copyright 2003-2006 PEAR <pear-group@php.net> |
---|
| 54 | * @license http://www.opensource.org/licenses/bsd-license.php BSD License |
---|
| 55 | * @version CVS: $Id: mimeDecode.php 305875 2010-12-01 07:17:10Z alan_k $ |
---|
| 56 | * @link http://pear.php.net/package/Mail_mime |
---|
| 57 | */ |
---|
| 58 | |
---|
| 59 | |
---|
| 60 | /** |
---|
| 61 | * require PEAR |
---|
| 62 | * |
---|
| 63 | * This package depends on PEAR to raise errors. |
---|
| 64 | */ |
---|
| 65 | //require_once 'PEAR.php'; |
---|
| 66 | |
---|
| 67 | |
---|
| 68 | /** |
---|
| 69 | * The Mail_mimeDecode class is used to decode mail/mime messages |
---|
| 70 | * |
---|
| 71 | * This class will parse a raw mime email and return the structure. |
---|
| 72 | * Returned structure is similar to that returned by imap_fetchstructure(). |
---|
| 73 | * |
---|
| 74 | * +----------------------------- IMPORTANT ------------------------------+ |
---|
| 75 | * | Usage of this class compared to native php extensions such as | |
---|
| 76 | * | mailparse or imap, is slow and may be feature deficient. If available| |
---|
| 77 | * | you are STRONGLY recommended to use the php extensions. | |
---|
| 78 | * +----------------------------------------------------------------------+ |
---|
| 79 | * |
---|
| 80 | * @category Mail |
---|
| 81 | * @package Mail_Mime |
---|
| 82 | * @author Richard Heyes <richard@phpguru.org> |
---|
| 83 | * @author George Schlossnagle <george@omniti.com> |
---|
| 84 | * @author Cipriano Groenendal <cipri@php.net> |
---|
| 85 | * @author Sean Coates <sean@php.net> |
---|
| 86 | * @copyright 2003-2006 PEAR <pear-group@php.net> |
---|
| 87 | * @license http://www.opensource.org/licenses/bsd-license.php BSD License |
---|
| 88 | * @version Release: @package_version@ |
---|
| 89 | * @link http://pear.php.net/package/Mail_mime |
---|
| 90 | */ |
---|
| 91 | class Mail_mimeDecode |
---|
| 92 | { |
---|
| 93 | /** |
---|
| 94 | * The raw email to decode |
---|
| 95 | * |
---|
| 96 | * @var string |
---|
| 97 | * @access private |
---|
| 98 | */ |
---|
| 99 | var $_input; |
---|
| 100 | |
---|
| 101 | /** |
---|
| 102 | * The header part of the input |
---|
| 103 | * |
---|
| 104 | * @var string |
---|
| 105 | * @access private |
---|
| 106 | */ |
---|
| 107 | var $_header; |
---|
| 108 | |
---|
| 109 | /** |
---|
| 110 | * The body part of the input |
---|
| 111 | * |
---|
| 112 | * @var string |
---|
| 113 | * @access private |
---|
| 114 | */ |
---|
| 115 | var $_body; |
---|
| 116 | |
---|
| 117 | /** |
---|
| 118 | * If an error occurs, this is used to store the message |
---|
| 119 | * |
---|
| 120 | * @var string |
---|
| 121 | * @access private |
---|
| 122 | */ |
---|
| 123 | var $_error; |
---|
| 124 | |
---|
| 125 | /** |
---|
| 126 | * Flag to determine whether to include bodies in the |
---|
| 127 | * returned object. |
---|
| 128 | * |
---|
| 129 | * @var boolean |
---|
| 130 | * @access private |
---|
| 131 | */ |
---|
| 132 | var $_include_bodies; |
---|
| 133 | |
---|
| 134 | /** |
---|
| 135 | * Flag to determine whether to decode bodies |
---|
| 136 | * |
---|
| 137 | * @var boolean |
---|
| 138 | * @access private |
---|
| 139 | */ |
---|
| 140 | var $_decode_bodies; |
---|
| 141 | |
---|
| 142 | /** |
---|
| 143 | * Flag to determine whether to decode headers |
---|
| 144 | * |
---|
| 145 | * @var boolean |
---|
| 146 | * @access private |
---|
| 147 | */ |
---|
| 148 | var $_decode_headers; |
---|
| 149 | |
---|
| 150 | /** |
---|
| 151 | * Flag to determine whether to include attached messages |
---|
| 152 | * as body in the returned object. Depends on $_include_bodies |
---|
| 153 | * |
---|
| 154 | * @var boolean |
---|
| 155 | * @access private |
---|
| 156 | */ |
---|
| 157 | var $_rfc822_bodies; |
---|
| 158 | |
---|
| 159 | /** |
---|
| 160 | * Constructor. |
---|
| 161 | * |
---|
| 162 | * Sets up the object, initialise the variables, and splits and |
---|
| 163 | * stores the header and body of the input. |
---|
| 164 | * |
---|
| 165 | * @param string The input to decode |
---|
| 166 | * @access public |
---|
| 167 | */ |
---|
| 168 | function Mail_mimeDecode($input) |
---|
| 169 | { |
---|
| 170 | list($header, $body) = $this->_splitBodyHeader($input); |
---|
| 171 | |
---|
| 172 | $this->_input = $input; |
---|
| 173 | $this->_header = $header; |
---|
| 174 | $this->_body = $body; |
---|
| 175 | $this->_decode_bodies = false; |
---|
| 176 | $this->_include_bodies = true; |
---|
| 177 | $this->_rfc822_bodies = false; |
---|
| 178 | } |
---|
| 179 | |
---|
| 180 | /** |
---|
| 181 | * Begins the decoding process. If called statically |
---|
| 182 | * it will create an object and call the decode() method |
---|
| 183 | * of it. |
---|
| 184 | * |
---|
| 185 | * @param array An array of various parameters that determine |
---|
| 186 | * various things: |
---|
| 187 | * include_bodies - Whether to include the body in the returned |
---|
| 188 | * object. |
---|
| 189 | * decode_bodies - Whether to decode the bodies |
---|
| 190 | * of the parts. (Transfer encoding) |
---|
| 191 | * decode_headers - Whether to decode headers |
---|
| 192 | * input - If called statically, this will be treated |
---|
| 193 | * as the input |
---|
| 194 | * @return object Decoded results |
---|
| 195 | * @access public |
---|
| 196 | */ |
---|
| 197 | function decode($params = null) |
---|
| 198 | { |
---|
| 199 | // determine if this method has been called statically |
---|
| 200 | $isStatic = empty($this) || !is_a($this, __CLASS__); |
---|
| 201 | |
---|
| 202 | // Have we been called statically? |
---|
| 203 | // If so, create an object and pass details to that. |
---|
| 204 | if ($isStatic AND isset($params['input'])) { |
---|
| 205 | |
---|
| 206 | $obj = new Mail_mimeDecode($params['input']); |
---|
| 207 | $structure = $obj->decode($params); |
---|
| 208 | |
---|
| 209 | // Called statically but no input |
---|
| 210 | } elseif ($isStatic) { |
---|
| 211 | return PEAR::raiseError('Called statically and no input given'); |
---|
| 212 | |
---|
| 213 | // Called via an object |
---|
| 214 | } else { |
---|
| 215 | $this->_include_bodies = isset($params['include_bodies']) ? |
---|
| 216 | $params['include_bodies'] : false; |
---|
| 217 | $this->_decode_bodies = isset($params['decode_bodies']) ? |
---|
| 218 | $params['decode_bodies'] : false; |
---|
| 219 | $this->_decode_headers = isset($params['decode_headers']) ? |
---|
| 220 | $params['decode_headers'] : false; |
---|
| 221 | $this->_rfc822_bodies = isset($params['rfc_822bodies']) ? |
---|
| 222 | $params['rfc_822bodies'] : false; |
---|
| 223 | |
---|
| 224 | $structure = $this->_decode($this->_header, $this->_body); |
---|
| 225 | if ($structure === false) { |
---|
| 226 | $structure = $this->raiseError($this->_error); |
---|
| 227 | } |
---|
| 228 | } |
---|
| 229 | |
---|
| 230 | return $structure; |
---|
| 231 | } |
---|
| 232 | |
---|
| 233 | /** |
---|
| 234 | * Performs the decoding. Decodes the body string passed to it |
---|
| 235 | * If it finds certain content-types it will call itself in a |
---|
| 236 | * recursive fashion |
---|
| 237 | * |
---|
| 238 | * @param string Header section |
---|
| 239 | * @param string Body section |
---|
| 240 | * @return object Results of decoding process |
---|
| 241 | * @access private |
---|
| 242 | */ |
---|
| 243 | function _decode($headers, $body, $default_ctype = 'text/plain') |
---|
| 244 | { |
---|
| 245 | $return = new stdClass; |
---|
| 246 | $return->headers = array(); |
---|
| 247 | $headers = $this->_parseHeaders($headers); |
---|
| 248 | |
---|
| 249 | foreach ($headers as $value) { |
---|
| 250 | $value['value'] = $this->_decode_headers ? $this->_decodeHeader($value['value']) : $value['value']; |
---|
| 251 | if (isset($return->headers[strtolower($value['name'])]) AND !is_array($return->headers[strtolower($value['name'])])) { |
---|
| 252 | $return->headers[strtolower($value['name'])] = array($return->headers[strtolower($value['name'])]); |
---|
| 253 | $return->headers[strtolower($value['name'])][] = $value['value']; |
---|
| 254 | |
---|
| 255 | } elseif (isset($return->headers[strtolower($value['name'])])) { |
---|
| 256 | $return->headers[strtolower($value['name'])][] = $value['value']; |
---|
| 257 | |
---|
| 258 | } else { |
---|
| 259 | $return->headers[strtolower($value['name'])] = $value['value']; |
---|
| 260 | } |
---|
| 261 | } |
---|
| 262 | |
---|
| 263 | |
---|
| 264 | foreach ($headers as $key => $value) { |
---|
| 265 | $headers[$key]['name'] = strtolower($headers[$key]['name']); |
---|
| 266 | switch ($headers[$key]['name']) { |
---|
| 267 | |
---|
| 268 | case 'content-type': |
---|
| 269 | $content_type = $this->_parseHeaderValue($headers[$key]['value']); |
---|
| 270 | |
---|
| 271 | if (preg_match('/([0-9a-z+.-]+)\/([0-9a-z+.-]+)/i', $content_type['value'], $regs)) { |
---|
| 272 | $return->ctype_primary = $regs[1]; |
---|
| 273 | $return->ctype_secondary = $regs[2]; |
---|
| 274 | } |
---|
| 275 | |
---|
| 276 | if (isset($content_type['other'])) { |
---|
| 277 | foreach($content_type['other'] as $p_name => $p_value) { |
---|
| 278 | $return->ctype_parameters[$p_name] = $p_value; |
---|
| 279 | } |
---|
| 280 | } |
---|
| 281 | break; |
---|
| 282 | |
---|
| 283 | case 'content-disposition': |
---|
| 284 | $content_disposition = $this->_parseHeaderValue($headers[$key]['value']); |
---|
| 285 | $return->disposition = $content_disposition['value']; |
---|
| 286 | if (isset($content_disposition['other'])) { |
---|
| 287 | foreach($content_disposition['other'] as $p_name => $p_value) { |
---|
| 288 | $return->d_parameters[$p_name] = $p_value; |
---|
| 289 | } |
---|
| 290 | } |
---|
| 291 | break; |
---|
| 292 | |
---|
| 293 | case 'content-transfer-encoding': |
---|
| 294 | $content_transfer_encoding = $this->_parseHeaderValue($headers[$key]['value']); |
---|
| 295 | break; |
---|
| 296 | } |
---|
| 297 | } |
---|
| 298 | |
---|
| 299 | if (isset($content_type)) { |
---|
| 300 | switch (strtolower($content_type['value'])) { |
---|
| 301 | case 'text/plain': |
---|
| 302 | $encoding = isset($content_transfer_encoding) ? $content_transfer_encoding['value'] : '7bit'; |
---|
| 303 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $encoding) : $body) : null; |
---|
| 304 | break; |
---|
| 305 | |
---|
| 306 | case 'text/html': |
---|
| 307 | $encoding = isset($content_transfer_encoding) ? $content_transfer_encoding['value'] : '7bit'; |
---|
| 308 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $encoding) : $body) : null; |
---|
| 309 | break; |
---|
| 310 | |
---|
| 311 | case 'multipart/parallel': |
---|
| 312 | case 'multipart/appledouble': // Appledouble mail |
---|
| 313 | case 'multipart/report': // RFC1892 |
---|
| 314 | case 'multipart/signed': // PGP |
---|
| 315 | case 'multipart/digest': |
---|
| 316 | case 'multipart/alternative': |
---|
| 317 | case 'multipart/related': |
---|
| 318 | case 'multipart/mixed': |
---|
| 319 | case 'application/vnd.wap.multipart.related': |
---|
| 320 | if(!isset($content_type['other']['boundary'])){ |
---|
| 321 | $this->_error = 'No boundary found for ' . $content_type['value'] . ' part'; |
---|
| 322 | return false; |
---|
| 323 | } |
---|
| 324 | |
---|
| 325 | $default_ctype = (strtolower($content_type['value']) === 'multipart/digest') ? 'message/rfc822' : 'text/plain'; |
---|
| 326 | |
---|
| 327 | $parts = $this->_boundarySplit($body, $content_type['other']['boundary']); |
---|
[7673] | 328 | $parts_count = count($parts); |
---|
| 329 | for ($i = 0; $i < $parts_count; ++$i) { |
---|
[4414] | 330 | list($part_header, $part_body) = $this->_splitBodyHeader($parts[$i]); |
---|
| 331 | $part = $this->_decode($part_header, $part_body, $default_ctype); |
---|
| 332 | if($part === false) |
---|
| 333 | $part = $this->raiseError($this->_error); |
---|
| 334 | $return->parts[] = $part; |
---|
| 335 | } |
---|
| 336 | break; |
---|
| 337 | |
---|
| 338 | case 'message/rfc822': |
---|
| 339 | if ($this->_rfc822_bodies) { |
---|
| 340 | $encoding = isset($content_transfer_encoding) ? $content_transfer_encoding['value'] : '7bit'; |
---|
| 341 | $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $encoding) : $body); |
---|
| 342 | } |
---|
| 343 | $obj = new Mail_mimeDecode($body); |
---|
| 344 | $return->parts[] = $obj->decode(array('include_bodies' => $this->_include_bodies, |
---|
| 345 | 'decode_bodies' => $this->_decode_bodies, |
---|
| 346 | 'decode_headers' => $this->_decode_headers)); |
---|
| 347 | unset($obj); |
---|
| 348 | break; |
---|
| 349 | |
---|
| 350 | case 'message/delivery-status': |
---|
| 351 | if(!isset($content_transfer_encoding['value'])) |
---|
| 352 | $content_transfer_encoding['value'] = '7bit'; |
---|
| 353 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $content_transfer_encoding['value']) : $body) : null; |
---|
| 354 | break; |
---|
| 355 | |
---|
| 356 | default: |
---|
| 357 | if(!isset($content_transfer_encoding['value'])) |
---|
| 358 | $content_transfer_encoding['value'] = '7bit'; |
---|
| 359 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $content_transfer_encoding['value']) : $body) : null; |
---|
| 360 | break; |
---|
| 361 | } |
---|
| 362 | |
---|
| 363 | } else { |
---|
| 364 | $ctype = explode('/', $default_ctype); |
---|
| 365 | $return->ctype_primary = $ctype[0]; |
---|
| 366 | $return->ctype_secondary = $ctype[1]; |
---|
| 367 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body) : $body) : null; |
---|
| 368 | } |
---|
| 369 | |
---|
| 370 | return $return; |
---|
| 371 | } |
---|
| 372 | |
---|
| 373 | /** |
---|
| 374 | * Given the output of the above function, this will return an |
---|
| 375 | * array of references to the parts, indexed by mime number. |
---|
| 376 | * |
---|
| 377 | * @param object $structure The structure to go through |
---|
| 378 | * @param string $mime_number Internal use only. |
---|
| 379 | * @return array Mime numbers |
---|
| 380 | */ |
---|
| 381 | function &getMimeNumbers(&$structure, $no_refs = false, $mime_number = '', $prepend = '') |
---|
| 382 | { |
---|
| 383 | $return = array(); |
---|
| 384 | if (!empty($structure->parts)) { |
---|
| 385 | if ($mime_number != '') { |
---|
| 386 | $structure->mime_id = $prepend . $mime_number; |
---|
| 387 | $return[$prepend . $mime_number] = &$structure; |
---|
| 388 | } |
---|
[7673] | 389 | $structure_parts_count = count($structure->parts); |
---|
| 390 | for ($i = 0; $i < $structure_parts_count; ++$i) { |
---|
[4414] | 391 | |
---|
| 392 | if (!empty($structure->headers['content-type']) AND substr(strtolower($structure->headers['content-type']), 0, 8) == 'message/') { |
---|
| 393 | $prepend = $prepend . $mime_number . '.'; |
---|
| 394 | $_mime_number = ''; |
---|
| 395 | } else { |
---|
| 396 | $_mime_number = ($mime_number == '' ? $i + 1 : sprintf('%s.%s', $mime_number, $i + 1)); |
---|
| 397 | } |
---|
| 398 | |
---|
| 399 | $arr = &Mail_mimeDecode::getMimeNumbers($structure->parts[$i], $no_refs, $_mime_number, $prepend); |
---|
| 400 | foreach ($arr as $key => $val) { |
---|
| 401 | $no_refs ? $return[$key] = '' : $return[$key] = &$arr[$key]; |
---|
| 402 | } |
---|
| 403 | } |
---|
| 404 | } else { |
---|
| 405 | if ($mime_number == '') { |
---|
| 406 | $mime_number = '1'; |
---|
| 407 | } |
---|
| 408 | $structure->mime_id = $prepend . $mime_number; |
---|
| 409 | $no_refs ? $return[$prepend . $mime_number] = '' : $return[$prepend . $mime_number] = &$structure; |
---|
| 410 | } |
---|
| 411 | |
---|
| 412 | return $return; |
---|
| 413 | } |
---|
| 414 | |
---|
| 415 | /** |
---|
| 416 | * Given a string containing a header and body |
---|
| 417 | * section, this function will split them (at the first |
---|
| 418 | * blank line) and return them. |
---|
| 419 | * |
---|
| 420 | * @param string Input to split apart |
---|
| 421 | * @return array Contains header and body section |
---|
| 422 | * @access private |
---|
| 423 | */ |
---|
| 424 | function _splitBodyHeader($input) |
---|
| 425 | { |
---|
| 426 | if (preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $input, $match)) { |
---|
| 427 | return array($match[1], $match[2]); |
---|
| 428 | } |
---|
| 429 | // bug #17325 - empty bodies are allowed. - we just check that at least one line |
---|
| 430 | // of headers exist.. |
---|
| 431 | if (count(explode("\n",$input))) { |
---|
| 432 | return array($input, ''); |
---|
| 433 | } |
---|
| 434 | $this->_error = 'Could not split header and body'; |
---|
| 435 | return false; |
---|
| 436 | } |
---|
| 437 | |
---|
| 438 | /** |
---|
| 439 | * Parse headers given in $input and return |
---|
| 440 | * as assoc array. |
---|
| 441 | * |
---|
| 442 | * @param string Headers to parse |
---|
| 443 | * @return array Contains parsed headers |
---|
| 444 | * @access private |
---|
| 445 | */ |
---|
| 446 | function _parseHeaders($input) |
---|
| 447 | { |
---|
| 448 | |
---|
| 449 | if ($input !== '') { |
---|
| 450 | // Unfold the input |
---|
| 451 | $input = preg_replace("/\r?\n/", "\r\n", $input); |
---|
| 452 | //#7065 - wrapping.. with encoded stuff.. - probably not needed, |
---|
| 453 | // wrapping space should only get removed if the trailing item on previous line is a |
---|
| 454 | // encoded character |
---|
| 455 | $input = preg_replace("/=\r\n(\t| )+/", '=', $input); |
---|
| 456 | $input = preg_replace("/\r\n(\t| )+/", ' ', $input); |
---|
| 457 | |
---|
| 458 | $headers = explode("\r\n", trim($input)); |
---|
| 459 | |
---|
| 460 | foreach ($headers as $value) { |
---|
| 461 | $hdr_name = substr($value, 0, $pos = strpos($value, ':')); |
---|
| 462 | $hdr_value = substr($value, $pos+1); |
---|
| 463 | if($hdr_value[0] == ' ') |
---|
| 464 | $hdr_value = substr($hdr_value, 1); |
---|
| 465 | |
---|
| 466 | $return[] = array( |
---|
| 467 | 'name' => $hdr_name, |
---|
| 468 | 'value' => $hdr_value |
---|
| 469 | ); |
---|
| 470 | } |
---|
| 471 | } else { |
---|
| 472 | $return = array(); |
---|
| 473 | } |
---|
| 474 | |
---|
| 475 | return $return; |
---|
| 476 | } |
---|
| 477 | |
---|
| 478 | /** |
---|
| 479 | * Function to parse a header value, |
---|
| 480 | * extract first part, and any secondary |
---|
| 481 | * parts (after ;) This function is not as |
---|
| 482 | * robust as it could be. Eg. header comments |
---|
| 483 | * in the wrong place will probably break it. |
---|
| 484 | * |
---|
| 485 | * @param string Header value to parse |
---|
| 486 | * @return array Contains parsed result |
---|
| 487 | * @access private |
---|
| 488 | */ |
---|
| 489 | function _parseHeaderValue($input) |
---|
| 490 | { |
---|
| 491 | |
---|
| 492 | if (($pos = strpos($input, ';')) === false) { |
---|
| 493 | $input = $this->_decode_headers ? $this->_decodeHeader($input) : $input; |
---|
| 494 | $return['value'] = trim($input); |
---|
| 495 | return $return; |
---|
| 496 | } |
---|
| 497 | |
---|
| 498 | |
---|
| 499 | |
---|
| 500 | $value = substr($input, 0, $pos); |
---|
| 501 | $value = $this->_decode_headers ? $this->_decodeHeader($value) : $value; |
---|
| 502 | $return['value'] = trim($value); |
---|
| 503 | $input = trim(substr($input, $pos+1)); |
---|
| 504 | |
---|
| 505 | if (!strlen($input) > 0) { |
---|
| 506 | return $return; |
---|
| 507 | } |
---|
| 508 | // at this point input contains xxxx=".....";zzzz="...." |
---|
| 509 | // since we are dealing with quoted strings, we need to handle this properly.. |
---|
| 510 | $i = 0; |
---|
| 511 | $l = strlen($input); |
---|
| 512 | $key = ''; |
---|
| 513 | $val = false; // our string - including quotes.. |
---|
| 514 | $q = false; // in quote.. |
---|
| 515 | $lq = ''; // last quote.. |
---|
| 516 | |
---|
| 517 | while ($i < $l) { |
---|
| 518 | |
---|
| 519 | $c = $input[$i]; |
---|
| 520 | //var_dump(array('i'=>$i,'c'=>$c,'q'=>$q, 'lq'=>$lq, 'key'=>$key, 'val' =>$val)); |
---|
| 521 | |
---|
| 522 | $escaped = false; |
---|
| 523 | if ($c == '\\') { |
---|
[7655] | 524 | ++$i; |
---|
[4414] | 525 | if ($i == $l-1) { // end of string. |
---|
| 526 | break; |
---|
| 527 | } |
---|
| 528 | $escaped = true; |
---|
| 529 | $c = $input[$i]; |
---|
| 530 | } |
---|
| 531 | |
---|
| 532 | |
---|
| 533 | // state - in key.. |
---|
| 534 | if ($val === false) { |
---|
| 535 | if (!$escaped && $c == '=') { |
---|
| 536 | $val = ''; |
---|
| 537 | $key = trim($key); |
---|
[7655] | 538 | ++$i; |
---|
[4414] | 539 | continue; |
---|
| 540 | } |
---|
| 541 | if (!$escaped && $c == ';') { |
---|
| 542 | if ($key) { // a key without a value.. |
---|
| 543 | $key= trim($key); |
---|
| 544 | $return['other'][$key] = ''; |
---|
| 545 | $return['other'][strtolower($key)] = ''; |
---|
| 546 | } |
---|
| 547 | $key = ''; |
---|
| 548 | } |
---|
| 549 | $key .= $c; |
---|
[7655] | 550 | ++$i; |
---|
[4414] | 551 | continue; |
---|
| 552 | } |
---|
| 553 | |
---|
| 554 | // state - in value.. (as $val is set..) |
---|
| 555 | |
---|
| 556 | if ($q === false) { |
---|
| 557 | // not in quote yet. |
---|
| 558 | if ((!strlen($val) || $lq !== false) && $c == ' ' || $c == "\t") { |
---|
[7655] | 559 | ++$i; |
---|
[4414] | 560 | continue; // skip leading spaces after '=' or after '"' |
---|
| 561 | } |
---|
| 562 | if (!$escaped && ($c == '"' || $c == "'")) { |
---|
| 563 | // start quoted area.. |
---|
| 564 | $q = $c; |
---|
| 565 | // in theory should not happen raw text in value part.. |
---|
| 566 | // but we will handle it as a merged part of the string.. |
---|
| 567 | $val = !strlen(trim($val)) ? '' : trim($val); |
---|
[7655] | 568 | ++$i; |
---|
[4414] | 569 | continue; |
---|
| 570 | } |
---|
| 571 | // got end.... |
---|
| 572 | if (!$escaped && $c == ';') { |
---|
| 573 | |
---|
| 574 | $val = trim($val); |
---|
| 575 | $added = false; |
---|
| 576 | if (preg_match('/\*[0-9]+$/', $key)) { |
---|
| 577 | // this is the extended aaa*0=...;aaa*1=.... code |
---|
| 578 | // it assumes the pieces arrive in order, and are valid... |
---|
| 579 | $key = preg_replace('/\*[0-9]+$/', '', $key); |
---|
| 580 | if (isset($return['other'][$key])) { |
---|
| 581 | $return['other'][$key] .= $val; |
---|
| 582 | if (strtolower($key) != $key) { |
---|
| 583 | $return['other'][strtolower($key)] .= $val; |
---|
| 584 | } |
---|
| 585 | $added = true; |
---|
| 586 | } |
---|
| 587 | // continue and use standard setters.. |
---|
| 588 | } |
---|
| 589 | if (!$added) { |
---|
| 590 | $return['other'][$key] = $val; |
---|
| 591 | $return['other'][strtolower($key)] = $val; |
---|
| 592 | } |
---|
| 593 | $val = false; |
---|
| 594 | $key = ''; |
---|
| 595 | $lq = false; |
---|
[7655] | 596 | ++$i; |
---|
[4414] | 597 | continue; |
---|
| 598 | } |
---|
| 599 | |
---|
| 600 | $val .= $c; |
---|
[7655] | 601 | ++$i; |
---|
[4414] | 602 | continue; |
---|
| 603 | } |
---|
| 604 | |
---|
| 605 | // state - in quote.. |
---|
| 606 | if (!$escaped && $c == $q) { // potential exit state.. |
---|
| 607 | |
---|
| 608 | // end of quoted string.. |
---|
| 609 | $lq = $q; |
---|
| 610 | $q = false; |
---|
[7655] | 611 | ++$i; |
---|
[4414] | 612 | continue; |
---|
| 613 | } |
---|
| 614 | |
---|
| 615 | // normal char inside of quoted string.. |
---|
| 616 | $val.= $c; |
---|
[7655] | 617 | ++$i; |
---|
[4414] | 618 | } |
---|
| 619 | |
---|
| 620 | // do we have anything left.. |
---|
| 621 | if (strlen(trim($key)) || $val !== false) { |
---|
| 622 | |
---|
| 623 | $val = trim($val); |
---|
| 624 | $added = false; |
---|
| 625 | if ($val !== false && preg_match('/\*[0-9]+$/', $key)) { |
---|
| 626 | // no dupes due to our crazy regexp. |
---|
| 627 | $key = preg_replace('/\*[0-9]+$/', '', $key); |
---|
| 628 | if (isset($return['other'][$key])) { |
---|
| 629 | $return['other'][$key] .= $val; |
---|
| 630 | if (strtolower($key) != $key) { |
---|
| 631 | $return['other'][strtolower($key)] .= $val; |
---|
| 632 | } |
---|
| 633 | $added = true; |
---|
| 634 | } |
---|
| 635 | // continue and use standard setters.. |
---|
| 636 | } |
---|
| 637 | if (!$added) { |
---|
| 638 | $return['other'][$key] = $val; |
---|
| 639 | $return['other'][strtolower($key)] = $val; |
---|
| 640 | } |
---|
| 641 | } |
---|
| 642 | // decode values. |
---|
| 643 | foreach($return['other'] as $key =>$val) { |
---|
| 644 | $return['other'][$key] = $this->_decode_headers ? $this->_decodeHeader($val) : $val; |
---|
| 645 | } |
---|
| 646 | //print_r($return); |
---|
| 647 | return $return; |
---|
| 648 | } |
---|
| 649 | |
---|
| 650 | /** |
---|
| 651 | * This function splits the input based |
---|
| 652 | * on the given boundary |
---|
| 653 | * |
---|
| 654 | * @param string Input to parse |
---|
| 655 | * @return array Contains array of resulting mime parts |
---|
| 656 | * @access private |
---|
| 657 | */ |
---|
| 658 | function _boundarySplit($input, $boundary) |
---|
| 659 | { |
---|
| 660 | $parts = array(); |
---|
| 661 | |
---|
| 662 | $bs_possible = substr($boundary, 2, -2); |
---|
| 663 | $bs_check = '\"' . $bs_possible . '\"'; |
---|
| 664 | |
---|
| 665 | if ($boundary == $bs_check) { |
---|
| 666 | $boundary = $bs_possible; |
---|
| 667 | } |
---|
[6063] | 668 | $tmp = preg_split("/--".preg_quote($boundary, '/')."((?=\s)|--)/", $input); |
---|
[4414] | 669 | |
---|
| 670 | $len = count($tmp) -1; |
---|
[7655] | 671 | for ($i = 1; $i < $len; ++$i) { |
---|
[4414] | 672 | if (strlen(trim($tmp[$i]))) { |
---|
| 673 | $parts[] = $tmp[$i]; |
---|
| 674 | } |
---|
| 675 | } |
---|
| 676 | |
---|
| 677 | // add the last part on if it does not end with the 'closing indicator' |
---|
| 678 | if (!empty($tmp[$len]) && strlen(trim($tmp[$len])) && $tmp[$len][0] != '-') { |
---|
| 679 | $parts[] = $tmp[$len]; |
---|
| 680 | } |
---|
| 681 | return $parts; |
---|
| 682 | } |
---|
| 683 | |
---|
| 684 | /** |
---|
| 685 | * Given a header, this function will decode it |
---|
| 686 | * according to RFC2047. Probably not *exactly* |
---|
| 687 | * conformant, but it does pass all the given |
---|
| 688 | * examples (in RFC2047). |
---|
| 689 | * |
---|
| 690 | * @param string Input header value to decode |
---|
| 691 | * @return string Decoded header value |
---|
| 692 | * @access private |
---|
| 693 | */ |
---|
| 694 | function _decodeHeader($input) |
---|
| 695 | { |
---|
| 696 | // Remove white space between encoded-words |
---|
| 697 | $input = preg_replace('/(=\?[^?]+\?(q|b)\?[^?]*\?=)(\s)+=\?/i', '\1=?', $input); |
---|
| 698 | |
---|
| 699 | // For each encoded-word... |
---|
| 700 | while (preg_match('/(=\?([^?]+)\?(q|b)\?([^?]*)\?=)/i', $input, $matches)) { |
---|
| 701 | |
---|
| 702 | $encoded = $matches[1]; |
---|
| 703 | $charset = $matches[2]; |
---|
| 704 | $encoding = $matches[3]; |
---|
| 705 | $text = $matches[4]; |
---|
| 706 | |
---|
| 707 | switch (strtolower($encoding)) { |
---|
| 708 | case 'b': |
---|
| 709 | $text = base64_decode($text); |
---|
| 710 | break; |
---|
| 711 | |
---|
| 712 | case 'q': |
---|
| 713 | $text = str_replace('_', ' ', $text); |
---|
| 714 | preg_match_all('/=([a-f0-9]{2})/i', $text, $matches); |
---|
| 715 | foreach($matches[1] as $value) |
---|
| 716 | $text = str_replace('='.$value, chr(hexdec($value)), $text); |
---|
| 717 | break; |
---|
| 718 | } |
---|
| 719 | |
---|
| 720 | $input = str_replace($encoded, $text, $input); |
---|
| 721 | } |
---|
| 722 | |
---|
| 723 | return $input; |
---|
| 724 | } |
---|
| 725 | |
---|
| 726 | /** |
---|
| 727 | * Given a body string and an encoding type, |
---|
| 728 | * this function will decode and return it. |
---|
| 729 | * |
---|
| 730 | * @param string Input body to decode |
---|
| 731 | * @param string Encoding type to use. |
---|
| 732 | * @return string Decoded body |
---|
| 733 | * @access private |
---|
| 734 | */ |
---|
| 735 | function _decodeBody($input, $encoding = '7bit') |
---|
| 736 | { |
---|
| 737 | switch (strtolower($encoding)) { |
---|
| 738 | case '7bit': |
---|
| 739 | return $input; |
---|
| 740 | break; |
---|
| 741 | |
---|
| 742 | case 'quoted-printable': |
---|
| 743 | return $this->_quotedPrintableDecode($input); |
---|
| 744 | break; |
---|
| 745 | |
---|
| 746 | case 'base64': |
---|
| 747 | return base64_decode($input); |
---|
| 748 | break; |
---|
| 749 | |
---|
| 750 | default: |
---|
| 751 | return $input; |
---|
| 752 | } |
---|
| 753 | } |
---|
| 754 | |
---|
| 755 | /** |
---|
| 756 | * Given a quoted-printable string, this |
---|
| 757 | * function will decode and return it. |
---|
| 758 | * |
---|
| 759 | * @param string Input body to decode |
---|
| 760 | * @return string Decoded body |
---|
| 761 | * @access private |
---|
| 762 | */ |
---|
| 763 | function _quotedPrintableDecode($input) |
---|
| 764 | { |
---|
| 765 | // Remove soft line breaks |
---|
| 766 | $input = preg_replace("/=\r?\n/", '', $input); |
---|
| 767 | |
---|
| 768 | // Replace encoded characters |
---|
| 769 | $input = preg_replace('/=([a-f0-9]{2})/ie', "chr(hexdec('\\1'))", $input); |
---|
| 770 | |
---|
| 771 | return $input; |
---|
| 772 | } |
---|
| 773 | |
---|
| 774 | /** |
---|
| 775 | * Checks the input for uuencoded files and returns |
---|
| 776 | * an array of them. Can be called statically, eg: |
---|
| 777 | * |
---|
| 778 | * $files =& Mail_mimeDecode::uudecode($some_text); |
---|
| 779 | * |
---|
| 780 | * It will check for the begin 666 ... end syntax |
---|
| 781 | * however and won't just blindly decode whatever you |
---|
| 782 | * pass it. |
---|
| 783 | * |
---|
| 784 | * @param string Input body to look for attahcments in |
---|
| 785 | * @return array Decoded bodies, filenames and permissions |
---|
| 786 | * @access public |
---|
| 787 | * @author Unknown |
---|
| 788 | */ |
---|
| 789 | function &uudecode($input) |
---|
| 790 | { |
---|
| 791 | |
---|
| 792 | // Find all uuencoded sections |
---|
| 793 | preg_match_all("/begin ([0-7]{3}) (.+)\r?\n(.+)\r?\nend/Us", $input, $matches); |
---|
| 794 | |
---|
[7673] | 795 | $matches_count = count($matches[3]); |
---|
| 796 | for ($j = 0; $j < $matches_count; ++$j) { |
---|
[4414] | 797 | |
---|
| 798 | $str = $matches[3][$j]; |
---|
| 799 | $filename = $matches[2][$j]; |
---|
| 800 | $fileperm = $matches[1][$j]; |
---|
| 801 | |
---|
| 802 | $file = ''; |
---|
[6057] | 803 | $str = preg_split('/\r?\n/', trim($str)); |
---|
[4414] | 804 | $strlen = count($str); |
---|
| 805 | |
---|
[7655] | 806 | for ($i = 0; $i < $strlen; ++$i) { |
---|
[4414] | 807 | $pos = 1; |
---|
| 808 | $d = 0; |
---|
| 809 | $len=(int)(((ord(substr($str[$i],0,1)) -32) - ' ') & 077); |
---|
| 810 | |
---|
| 811 | while (($d + 3 <= $len) AND ($pos + 4 <= strlen($str[$i]))) { |
---|
| 812 | $c0 = (ord(substr($str[$i],$pos,1)) ^ 0x20); |
---|
| 813 | $c1 = (ord(substr($str[$i],$pos+1,1)) ^ 0x20); |
---|
| 814 | $c2 = (ord(substr($str[$i],$pos+2,1)) ^ 0x20); |
---|
| 815 | $c3 = (ord(substr($str[$i],$pos+3,1)) ^ 0x20); |
---|
| 816 | $file .= chr(((($c0 - ' ') & 077) << 2) | ((($c1 - ' ') & 077) >> 4)); |
---|
| 817 | |
---|
| 818 | $file .= chr(((($c1 - ' ') & 077) << 4) | ((($c2 - ' ') & 077) >> 2)); |
---|
| 819 | |
---|
| 820 | $file .= chr(((($c2 - ' ') & 077) << 6) | (($c3 - ' ') & 077)); |
---|
| 821 | |
---|
| 822 | $pos += 4; |
---|
| 823 | $d += 3; |
---|
| 824 | } |
---|
| 825 | |
---|
| 826 | if (($d + 2 <= $len) && ($pos + 3 <= strlen($str[$i]))) { |
---|
| 827 | $c0 = (ord(substr($str[$i],$pos,1)) ^ 0x20); |
---|
| 828 | $c1 = (ord(substr($str[$i],$pos+1,1)) ^ 0x20); |
---|
| 829 | $c2 = (ord(substr($str[$i],$pos+2,1)) ^ 0x20); |
---|
| 830 | $file .= chr(((($c0 - ' ') & 077) << 2) | ((($c1 - ' ') & 077) >> 4)); |
---|
| 831 | |
---|
| 832 | $file .= chr(((($c1 - ' ') & 077) << 4) | ((($c2 - ' ') & 077) >> 2)); |
---|
| 833 | |
---|
| 834 | $pos += 3; |
---|
| 835 | $d += 2; |
---|
| 836 | } |
---|
| 837 | |
---|
| 838 | if (($d + 1 <= $len) && ($pos + 2 <= strlen($str[$i]))) { |
---|
| 839 | $c0 = (ord(substr($str[$i],$pos,1)) ^ 0x20); |
---|
| 840 | $c1 = (ord(substr($str[$i],$pos+1,1)) ^ 0x20); |
---|
| 841 | $file .= chr(((($c0 - ' ') & 077) << 2) | ((($c1 - ' ') & 077) >> 4)); |
---|
| 842 | |
---|
| 843 | } |
---|
| 844 | } |
---|
| 845 | $files[] = array('filename' => $filename, 'fileperm' => $fileperm, 'filedata' => $file); |
---|
| 846 | } |
---|
| 847 | |
---|
| 848 | return $files; |
---|
| 849 | } |
---|
| 850 | |
---|
| 851 | /** |
---|
| 852 | * getSendArray() returns the arguments required for Mail::send() |
---|
| 853 | * used to build the arguments for a mail::send() call |
---|
| 854 | * |
---|
| 855 | * Usage: |
---|
| 856 | * $mailtext = Full email (for example generated by a template) |
---|
| 857 | * $decoder = new Mail_mimeDecode($mailtext); |
---|
| 858 | * $parts = $decoder->getSendArray(); |
---|
| 859 | * if (!PEAR::isError($parts) { |
---|
| 860 | * list($recipents,$headers,$body) = $parts; |
---|
| 861 | * $mail = Mail::factory('smtp'); |
---|
| 862 | * $mail->send($recipents,$headers,$body); |
---|
| 863 | * } else { |
---|
| 864 | * echo $parts->message; |
---|
| 865 | * } |
---|
| 866 | * @return mixed array of recipeint, headers,body or Pear_Error |
---|
| 867 | * @access public |
---|
| 868 | * @author Alan Knowles <alan@akbkhome.com> |
---|
| 869 | */ |
---|
| 870 | function getSendArray() |
---|
| 871 | { |
---|
| 872 | // prevent warning if this is not set |
---|
| 873 | $this->_decode_headers = FALSE; |
---|
| 874 | $headerlist =$this->_parseHeaders($this->_header); |
---|
| 875 | $to = ""; |
---|
| 876 | if (!$headerlist) { |
---|
| 877 | return $this->raiseError("Message did not contain headers"); |
---|
| 878 | } |
---|
| 879 | foreach($headerlist as $item) { |
---|
| 880 | $header[$item['name']] = $item['value']; |
---|
| 881 | switch (strtolower($item['name'])) { |
---|
| 882 | case "to": |
---|
| 883 | case "cc": |
---|
| 884 | case "bcc": |
---|
| 885 | $to .= ",".$item['value']; |
---|
| 886 | default: |
---|
| 887 | break; |
---|
| 888 | } |
---|
| 889 | } |
---|
| 890 | if ($to == "") { |
---|
| 891 | return $this->raiseError("Message did not contain any recipents"); |
---|
| 892 | } |
---|
| 893 | $to = substr($to,1); |
---|
| 894 | return array($to,$header,$this->_body); |
---|
| 895 | } |
---|
| 896 | |
---|
| 897 | /** |
---|
| 898 | * Returns a xml copy of the output of |
---|
| 899 | * Mail_mimeDecode::decode. Pass the output in as the |
---|
| 900 | * argument. This function can be called statically. Eg: |
---|
| 901 | * |
---|
| 902 | * $output = $obj->decode(); |
---|
| 903 | * $xml = Mail_mimeDecode::getXML($output); |
---|
| 904 | * |
---|
| 905 | * The DTD used for this should have been in the package. Or |
---|
| 906 | * alternatively you can get it from cvs, or here: |
---|
| 907 | * http://www.phpguru.org/xmail/xmail.dtd. |
---|
| 908 | * |
---|
| 909 | * @param object Input to convert to xml. This should be the |
---|
| 910 | * output of the Mail_mimeDecode::decode function |
---|
| 911 | * @return string XML version of input |
---|
| 912 | * @access public |
---|
| 913 | */ |
---|
| 914 | function getXML($input) |
---|
| 915 | { |
---|
| 916 | $crlf = "\r\n"; |
---|
| 917 | $output = '<?xml version=\'1.0\'?>' . $crlf . |
---|
| 918 | '<!DOCTYPE email SYSTEM "http://www.phpguru.org/xmail/xmail.dtd">' . $crlf . |
---|
| 919 | '<email>' . $crlf . |
---|
| 920 | Mail_mimeDecode::_getXML($input) . |
---|
| 921 | '</email>'; |
---|
| 922 | |
---|
| 923 | return $output; |
---|
| 924 | } |
---|
| 925 | |
---|
| 926 | /** |
---|
| 927 | * Function that does the actual conversion to xml. Does a single |
---|
| 928 | * mimepart at a time. |
---|
| 929 | * |
---|
| 930 | * @param object Input to convert to xml. This is a mimepart object. |
---|
| 931 | * It may or may not contain subparts. |
---|
| 932 | * @param integer Number of tabs to indent |
---|
| 933 | * @return string XML version of input |
---|
| 934 | * @access private |
---|
| 935 | */ |
---|
| 936 | function _getXML($input, $indent = 1) |
---|
| 937 | { |
---|
| 938 | $htab = "\t"; |
---|
| 939 | $crlf = "\r\n"; |
---|
| 940 | $output = ''; |
---|
| 941 | $headers = @(array)$input->headers; |
---|
| 942 | |
---|
| 943 | foreach ($headers as $hdr_name => $hdr_value) { |
---|
| 944 | |
---|
| 945 | // Multiple headers with this name |
---|
| 946 | if (is_array($headers[$hdr_name])) { |
---|
[7673] | 947 | $hdr_value_count = count($hdr_value); |
---|
| 948 | for ($i = 0; $i < $hdr_value_count; ++$i) { |
---|
[4414] | 949 | $output .= Mail_mimeDecode::_getXML_helper($hdr_name, $hdr_value[$i], $indent); |
---|
| 950 | } |
---|
| 951 | |
---|
| 952 | // Only one header of this sort |
---|
| 953 | } else { |
---|
| 954 | $output .= Mail_mimeDecode::_getXML_helper($hdr_name, $hdr_value, $indent); |
---|
| 955 | } |
---|
| 956 | } |
---|
| 957 | |
---|
| 958 | if (!empty($input->parts)) { |
---|
[7673] | 959 | $parts_count = count($input->parts); |
---|
| 960 | for ($i = 0; $i < $parts_count; ++$i) { |
---|
[4414] | 961 | $output .= $crlf . str_repeat($htab, $indent) . '<mimepart>' . $crlf . |
---|
| 962 | Mail_mimeDecode::_getXML($input->parts[$i], $indent+1) . |
---|
| 963 | str_repeat($htab, $indent) . '</mimepart>' . $crlf; |
---|
| 964 | } |
---|
| 965 | } elseif (isset($input->body)) { |
---|
| 966 | $output .= $crlf . str_repeat($htab, $indent) . '<body><![CDATA[' . |
---|
| 967 | $input->body . ']]></body>' . $crlf; |
---|
| 968 | } |
---|
| 969 | |
---|
| 970 | return $output; |
---|
| 971 | } |
---|
| 972 | |
---|
| 973 | /** |
---|
| 974 | * Helper function to _getXML(). Returns xml of a header. |
---|
| 975 | * |
---|
| 976 | * @param string Name of header |
---|
| 977 | * @param string Value of header |
---|
| 978 | * @param integer Number of tabs to indent |
---|
| 979 | * @return string XML version of input |
---|
| 980 | * @access private |
---|
| 981 | */ |
---|
| 982 | function _getXML_helper($hdr_name, $hdr_value, $indent) |
---|
| 983 | { |
---|
| 984 | $htab = "\t"; |
---|
| 985 | $crlf = "\r\n"; |
---|
| 986 | $return = ''; |
---|
| 987 | |
---|
| 988 | $new_hdr_value = ($hdr_name != 'received') ? Mail_mimeDecode::_parseHeaderValue($hdr_value) : array('value' => $hdr_value); |
---|
| 989 | $new_hdr_name = str_replace(' ', '-', ucwords(str_replace('-', ' ', $hdr_name))); |
---|
| 990 | |
---|
| 991 | // Sort out any parameters |
---|
| 992 | if (!empty($new_hdr_value['other'])) { |
---|
| 993 | foreach ($new_hdr_value['other'] as $paramname => $paramvalue) { |
---|
| 994 | $params[] = str_repeat($htab, $indent) . $htab . '<parameter>' . $crlf . |
---|
| 995 | str_repeat($htab, $indent) . $htab . $htab . '<paramname>' . htmlspecialchars($paramname) . '</paramname>' . $crlf . |
---|
| 996 | str_repeat($htab, $indent) . $htab . $htab . '<paramvalue>' . htmlspecialchars($paramvalue) . '</paramvalue>' . $crlf . |
---|
| 997 | str_repeat($htab, $indent) . $htab . '</parameter>' . $crlf; |
---|
| 998 | } |
---|
| 999 | |
---|
| 1000 | $params = implode('', $params); |
---|
| 1001 | } else { |
---|
| 1002 | $params = ''; |
---|
| 1003 | } |
---|
| 1004 | |
---|
| 1005 | $return = str_repeat($htab, $indent) . '<header>' . $crlf . |
---|
| 1006 | str_repeat($htab, $indent) . $htab . '<headername>' . htmlspecialchars($new_hdr_name) . '</headername>' . $crlf . |
---|
| 1007 | str_repeat($htab, $indent) . $htab . '<headervalue>' . htmlspecialchars($new_hdr_value['value']) . '</headervalue>' . $crlf . |
---|
| 1008 | $params . |
---|
| 1009 | str_repeat($htab, $indent) . '</header>' . $crlf; |
---|
| 1010 | |
---|
| 1011 | return $return; |
---|
| 1012 | } |
---|
| 1013 | |
---|
| 1014 | } // End of class |
---|