[3637] | 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. |
---|
[3754] | 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 |
---|
[3637] | 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 288500 2009-09-21 05:32:32Z alan_k $ |
---|
| 56 | * @link http://pear.php.net/package/Mail_mime |
---|
| 57 | */ |
---|
| 58 | |
---|
| 59 | |
---|
| 60 | /** |
---|
| 61 | * Z-Push changes |
---|
| 62 | * |
---|
| 63 | * removed PEAR dependency by implementing own raiseError() |
---|
| 64 | * removed deprecated referencing: $obj = &new Mail_mimeDecode($body); in _decode() |
---|
| 65 | * implemented automated decoding of strings from mail charset |
---|
[3754] | 66 | * |
---|
| 67 | * Reference implementation used: |
---|
[3637] | 68 | * http://download.pear.php.net/package/Mail_mimeDecode-1.5.1.tgz |
---|
[3754] | 69 | * |
---|
[3637] | 70 | */ |
---|
| 71 | |
---|
| 72 | /** |
---|
| 73 | * require PEAR |
---|
| 74 | * |
---|
| 75 | * This package depends on PEAR to raise errors. |
---|
| 76 | */ |
---|
| 77 | //require_once 'PEAR.php'; |
---|
| 78 | |
---|
| 79 | /** |
---|
| 80 | * The Mail_mimeDecode class is used to decode mail/mime messages |
---|
| 81 | * |
---|
| 82 | * This class will parse a raw mime email and return the structure. |
---|
| 83 | * Returned structure is similar to that returned by imap_fetchstructure(). |
---|
| 84 | * |
---|
| 85 | * +----------------------------- IMPORTANT ------------------------------+ |
---|
| 86 | * | Usage of this class compared to native php extensions such as | |
---|
| 87 | * | mailparse or imap, is slow and may be feature deficient. If available| |
---|
| 88 | * | you are STRONGLY recommended to use the php extensions. | |
---|
| 89 | * +----------------------------------------------------------------------+ |
---|
| 90 | * |
---|
| 91 | * @category Mail |
---|
| 92 | * @package Mail_Mime |
---|
| 93 | * @author Richard Heyes <richard@phpguru.org> |
---|
| 94 | * @author George Schlossnagle <george@omniti.com> |
---|
| 95 | * @author Cipriano Groenendal <cipri@php.net> |
---|
| 96 | * @author Sean Coates <sean@php.net> |
---|
| 97 | * @copyright 2003-2006 PEAR <pear-group@php.net> |
---|
| 98 | * @license http://www.opensource.org/licenses/bsd-license.php BSD License |
---|
| 99 | * @version Release: @package_version@ |
---|
| 100 | * @link http://pear.php.net/package/Mail_mime |
---|
| 101 | */ |
---|
| 102 | class Mail_mimeDecode |
---|
| 103 | { |
---|
[3754] | 104 | /** |
---|
| 105 | * The raw email to decode |
---|
| 106 | * |
---|
| 107 | * @var string |
---|
| 108 | * @access private |
---|
| 109 | */ |
---|
| 110 | var $_input; |
---|
[3637] | 111 | |
---|
[3754] | 112 | /** |
---|
| 113 | * The header part of the input |
---|
| 114 | * |
---|
| 115 | * @var string |
---|
| 116 | * @access private |
---|
| 117 | */ |
---|
| 118 | var $_header; |
---|
[3637] | 119 | |
---|
[3754] | 120 | /** |
---|
| 121 | * The body part of the input |
---|
| 122 | * |
---|
| 123 | * @var string |
---|
| 124 | * @access private |
---|
| 125 | */ |
---|
| 126 | var $_body; |
---|
[3637] | 127 | |
---|
[3754] | 128 | /** |
---|
| 129 | * If an error occurs, this is used to store the message |
---|
| 130 | * |
---|
| 131 | * @var string |
---|
| 132 | * @access private |
---|
| 133 | */ |
---|
| 134 | var $_error; |
---|
[3637] | 135 | |
---|
[3754] | 136 | /** |
---|
| 137 | * Flag to determine whether to include bodies in the |
---|
| 138 | * returned object. |
---|
| 139 | * |
---|
| 140 | * @var boolean |
---|
| 141 | * @access private |
---|
| 142 | */ |
---|
| 143 | var $_include_bodies; |
---|
[3637] | 144 | |
---|
[3754] | 145 | /** |
---|
| 146 | * Flag to determine whether to decode bodies |
---|
| 147 | * |
---|
| 148 | * @var boolean |
---|
| 149 | * @access private |
---|
| 150 | */ |
---|
| 151 | var $_decode_bodies; |
---|
[3637] | 152 | |
---|
[3754] | 153 | /** |
---|
| 154 | * Flag to determine whether to decode headers |
---|
| 155 | * |
---|
| 156 | * @var boolean |
---|
| 157 | * @access private |
---|
| 158 | */ |
---|
| 159 | var $_decode_headers; |
---|
[3637] | 160 | |
---|
[3754] | 161 | /** |
---|
| 162 | * Flag to determine whether to include attached messages |
---|
| 163 | * as body in the returned object. Depends on $_include_bodies |
---|
| 164 | * |
---|
| 165 | * @var boolean |
---|
| 166 | * @access private |
---|
| 167 | */ |
---|
| 168 | var $_rfc822_bodies; |
---|
[3637] | 169 | |
---|
[3754] | 170 | /** |
---|
| 171 | * Constructor. |
---|
| 172 | * |
---|
| 173 | * Sets up the object, initialise the variables, and splits and |
---|
| 174 | * stores the header and body of the input. |
---|
| 175 | * |
---|
| 176 | * @param string The input to decode |
---|
| 177 | * @access public |
---|
| 178 | */ |
---|
| 179 | function Mail_mimeDecode($input, $deprecated_linefeed = '') |
---|
| 180 | { |
---|
| 181 | list($header, $body) = $this->_splitBodyHeader($input); |
---|
[3637] | 182 | |
---|
[3754] | 183 | $this->_input = $input; |
---|
| 184 | $this->_header = $header; |
---|
| 185 | $this->_body = $body; |
---|
| 186 | $this->_decode_bodies = false; |
---|
| 187 | $this->_include_bodies = true; |
---|
| 188 | $this->_rfc822_bodies = false; |
---|
| 189 | } |
---|
[3637] | 190 | |
---|
[3754] | 191 | /** |
---|
| 192 | * Begins the decoding process. If called statically |
---|
| 193 | * it will create an object and call the decode() method |
---|
| 194 | * of it. |
---|
| 195 | * |
---|
| 196 | * @param array An array of various parameters that determine |
---|
| 197 | * various things: |
---|
| 198 | * include_bodies - Whether to include the body in the returned |
---|
| 199 | * object. |
---|
| 200 | * decode_bodies - Whether to decode the bodies |
---|
| 201 | * of the parts. (Transfer encoding) |
---|
| 202 | * decode_headers - Whether to decode headers |
---|
| 203 | * input - If called statically, this will be treated |
---|
| 204 | * as the input |
---|
| 205 | * charset - convert all data to this charset |
---|
| 206 | * @return object Decoded results |
---|
| 207 | * @access public |
---|
| 208 | */ |
---|
| 209 | function decode($params = null) |
---|
| 210 | { |
---|
| 211 | // determine if this method has been called statically |
---|
| 212 | $isStatic = !(isset($this) && get_class($this) == __CLASS__); |
---|
[3637] | 213 | |
---|
[3754] | 214 | // Have we been called statically? |
---|
| 215 | // If so, create an object and pass details to that. |
---|
| 216 | if ($isStatic AND isset($params['input'])) { |
---|
[3637] | 217 | |
---|
[3754] | 218 | $obj = new Mail_mimeDecode($params['input']); |
---|
| 219 | $structure = $obj->decode($params); |
---|
[3637] | 220 | |
---|
[3754] | 221 | // Called statically but no input |
---|
| 222 | } elseif ($isStatic) { |
---|
| 223 | return $this->raiseError('Called statically and no input given'); |
---|
[3637] | 224 | |
---|
[3754] | 225 | // Called via an object |
---|
| 226 | } else { |
---|
| 227 | $this->_include_bodies = isset($params['include_bodies']) ? |
---|
| 228 | $params['include_bodies'] : false; |
---|
| 229 | $this->_decode_bodies = isset($params['decode_bodies']) ? |
---|
| 230 | $params['decode_bodies'] : false; |
---|
| 231 | $this->_decode_headers = isset($params['decode_headers']) ? |
---|
| 232 | $params['decode_headers'] : false; |
---|
| 233 | $this->_rfc822_bodies = isset($params['rfc_822bodies']) ? |
---|
| 234 | $params['rfc_822bodies'] : false; |
---|
| 235 | $this->_charset = isset($params['charset']) ? |
---|
| 236 | $params['charset'] : 'utf-8'; |
---|
| 237 | |
---|
| 238 | $structure = $this->_decode($this->_header, $this->_body); |
---|
| 239 | if ($structure === false) { |
---|
| 240 | $structure = $this->raiseError($this->_error); |
---|
| 241 | } |
---|
| 242 | } |
---|
[3637] | 243 | |
---|
[3754] | 244 | return $structure; |
---|
| 245 | } |
---|
[3637] | 246 | |
---|
[3754] | 247 | /** |
---|
| 248 | * Performs the decoding. Decodes the body string passed to it |
---|
| 249 | * If it finds certain content-types it will call itself in a |
---|
| 250 | * recursive fashion |
---|
| 251 | * |
---|
| 252 | * @param string Header section |
---|
| 253 | * @param string Body section |
---|
| 254 | * @return object Results of decoding process |
---|
| 255 | * @access private |
---|
| 256 | */ |
---|
| 257 | function _decode($headers, $body, $default_ctype = 'text/plain') |
---|
| 258 | { |
---|
| 259 | $return = new stdClass; |
---|
| 260 | $return->headers = array(); |
---|
| 261 | $headers = $this->_parseHeaders($headers); |
---|
[3637] | 262 | |
---|
[3754] | 263 | foreach ($headers as $value) { |
---|
| 264 | if (isset($return->headers[strtolower($value['name'])]) AND !is_array($return->headers[strtolower($value['name'])])) { |
---|
| 265 | $return->headers[strtolower($value['name'])] = array($return->headers[strtolower($value['name'])]); |
---|
| 266 | $return->headers[strtolower($value['name'])][] = $value['value']; |
---|
[3637] | 267 | |
---|
[3754] | 268 | } elseif (isset($return->headers[strtolower($value['name'])])) { |
---|
| 269 | $return->headers[strtolower($value['name'])][] = $value['value']; |
---|
[3637] | 270 | |
---|
[3754] | 271 | } else { |
---|
| 272 | $return->headers[strtolower($value['name'])] = $value['value']; |
---|
| 273 | } |
---|
| 274 | } |
---|
[3637] | 275 | |
---|
[3754] | 276 | reset($headers); |
---|
| 277 | while (list($key, $value) = each($headers)) { |
---|
| 278 | $headers[$key]['name'] = strtolower($headers[$key]['name']); |
---|
| 279 | switch ($headers[$key]['name']) { |
---|
[3637] | 280 | |
---|
[3754] | 281 | case 'content-type': |
---|
| 282 | $content_type = $this->_parseHeaderValue($headers[$key]['value']); |
---|
[3637] | 283 | |
---|
[3754] | 284 | if (preg_match('/([0-9a-z+.-]+)\/([0-9a-z+.-]+)/i', $content_type['value'], $regs)) { |
---|
| 285 | $return->ctype_primary = $regs[1]; |
---|
| 286 | $return->ctype_secondary = $regs[2]; |
---|
| 287 | } |
---|
[3637] | 288 | |
---|
[3754] | 289 | if (isset($content_type['other'])) { |
---|
| 290 | while (list($p_name, $p_value) = each($content_type['other'])) { |
---|
| 291 | $return->ctype_parameters[$p_name] = $p_value; |
---|
| 292 | } |
---|
| 293 | } |
---|
| 294 | break; |
---|
[3637] | 295 | |
---|
[3754] | 296 | case 'content-disposition': |
---|
| 297 | $content_disposition = $this->_parseHeaderValue($headers[$key]['value']); |
---|
| 298 | $return->disposition = $content_disposition['value']; |
---|
| 299 | if (isset($content_disposition['other'])) { |
---|
| 300 | while (list($p_name, $p_value) = each($content_disposition['other'])) { |
---|
| 301 | $return->d_parameters[$p_name] = $p_value; |
---|
| 302 | } |
---|
| 303 | } |
---|
| 304 | break; |
---|
[3637] | 305 | |
---|
[3754] | 306 | case 'content-transfer-encoding': |
---|
| 307 | $content_transfer_encoding = $this->_parseHeaderValue($headers[$key]['value']); |
---|
| 308 | break; |
---|
| 309 | } |
---|
| 310 | } |
---|
[3637] | 311 | |
---|
[3754] | 312 | if (isset($content_type)) { |
---|
| 313 | switch (strtolower($content_type['value'])) { |
---|
| 314 | case 'text/plain': |
---|
| 315 | $encoding = isset($content_transfer_encoding) ? $content_transfer_encoding['value'] : '7bit'; |
---|
| 316 | $charset = isset($return->ctype_parameters['charset']) ? $return->ctype_parameters['charset'] : $this->_charset; |
---|
| 317 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $encoding, $charset) : $body) : null; |
---|
| 318 | break; |
---|
[3637] | 319 | |
---|
[3754] | 320 | case 'text/html': |
---|
| 321 | $encoding = isset($content_transfer_encoding) ? $content_transfer_encoding['value'] : '7bit'; |
---|
| 322 | $charset = isset($return->ctype_parameters['charset']) ? $return->ctype_parameters['charset'] : $this->_charset; |
---|
| 323 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $encoding, $charset) : $body) : null; |
---|
| 324 | break; |
---|
[3637] | 325 | |
---|
[3754] | 326 | case 'multipart/parallel': |
---|
| 327 | case 'multipart/appledouble': // Appledouble mail |
---|
| 328 | case 'multipart/report': // RFC1892 |
---|
| 329 | case 'multipart/signed': // PGP |
---|
| 330 | case 'multipart/digest': |
---|
| 331 | case 'multipart/alternative': |
---|
| 332 | case 'multipart/related': |
---|
| 333 | case 'multipart/mixed': |
---|
| 334 | if(!isset($content_type['other']['boundary'])){ |
---|
| 335 | $this->_error = 'No boundary found for ' . $content_type['value'] . ' part'; |
---|
| 336 | return false; |
---|
| 337 | } |
---|
[3637] | 338 | |
---|
[3754] | 339 | $default_ctype = (strtolower($content_type['value']) === 'multipart/digest') ? 'message/rfc822' : 'text/plain'; |
---|
[3637] | 340 | |
---|
[3754] | 341 | $parts = $this->_boundarySplit($body, $content_type['other']['boundary']); |
---|
| 342 | for ($i = 0; $i < count($parts); $i++) { |
---|
| 343 | list($part_header, $part_body) = $this->_splitBodyHeader($parts[$i]); |
---|
| 344 | $part = $this->_decode($part_header, $part_body, $default_ctype); |
---|
| 345 | if($part === false) |
---|
| 346 | $part = $this->raiseError($this->_error); |
---|
| 347 | $return->parts[] = $part; |
---|
| 348 | } |
---|
| 349 | break; |
---|
[3637] | 350 | |
---|
[3754] | 351 | case 'message/rfc822': |
---|
| 352 | if ($this->_rfc822_bodies) { |
---|
| 353 | $encoding = isset($content_transfer_encoding) ? $content_transfer_encoding['value'] : '7bit'; |
---|
| 354 | $charset = isset($return->ctype_parameters['charset']) ? $return->ctype_parameters['charset'] : $this->_charset; |
---|
| 355 | $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $encoding, $charset) : $body); |
---|
| 356 | } |
---|
[3637] | 357 | |
---|
[3754] | 358 | $obj = new Mail_mimeDecode($body); |
---|
| 359 | $return->parts[] = $obj->decode(array('include_bodies' => $this->_include_bodies, |
---|
[3637] | 360 | 'decode_bodies' => $this->_decode_bodies, |
---|
| 361 | 'decode_headers' => $this->_decode_headers)); |
---|
[3754] | 362 | unset($obj); |
---|
| 363 | break; |
---|
[3637] | 364 | |
---|
[3754] | 365 | default: |
---|
| 366 | if(!isset($content_transfer_encoding['value'])) |
---|
| 367 | $content_transfer_encoding['value'] = '7bit'; |
---|
| 368 | // if there is no explicit charset, then don't try to convert to default charset |
---|
| 369 | $charset = isset($return->ctype_parameters['charset']) ? $return->ctype_parameters['charset'] : ''; |
---|
| 370 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body, $content_transfer_encoding['value'], $charset) : $body) : null; |
---|
| 371 | break; |
---|
| 372 | } |
---|
[3637] | 373 | |
---|
[3754] | 374 | } else { |
---|
| 375 | $ctype = explode('/', $default_ctype); |
---|
| 376 | $return->ctype_primary = $ctype[0]; |
---|
| 377 | $return->ctype_secondary = $ctype[1]; |
---|
| 378 | $this->_include_bodies ? $return->body = ($this->_decode_bodies ? $this->_decodeBody($body) : $body) : null; |
---|
| 379 | } |
---|
[3637] | 380 | |
---|
[3754] | 381 | return $return; |
---|
| 382 | } |
---|
[3637] | 383 | |
---|
[3754] | 384 | /** |
---|
| 385 | * Given the output of the above function, this will return an |
---|
| 386 | * array of references to the parts, indexed by mime number. |
---|
| 387 | * |
---|
| 388 | * @param object $structure The structure to go through |
---|
| 389 | * @param string $mime_number Internal use only. |
---|
| 390 | * @return array Mime numbers |
---|
| 391 | */ |
---|
| 392 | function &getMimeNumbers(&$structure, $no_refs = false, $mime_number = '', $prepend = '') |
---|
| 393 | { |
---|
| 394 | $return = array(); |
---|
| 395 | if (!empty($structure->parts)) { |
---|
| 396 | if ($mime_number != '') { |
---|
| 397 | $structure->mime_id = $prepend . $mime_number; |
---|
| 398 | $return[$prepend . $mime_number] = &$structure; |
---|
| 399 | } |
---|
| 400 | for ($i = 0; $i < count($structure->parts); $i++) { |
---|
[3637] | 401 | |
---|
| 402 | |
---|
[3754] | 403 | if (!empty($structure->headers['content-type']) AND substr(strtolower($structure->headers['content-type']), 0, 8) == 'message/') { |
---|
| 404 | $prepend = $prepend . $mime_number . '.'; |
---|
| 405 | $_mime_number = ''; |
---|
| 406 | } else { |
---|
| 407 | $_mime_number = ($mime_number == '' ? $i + 1 : sprintf('%s.%s', $mime_number, $i + 1)); |
---|
| 408 | } |
---|
[3637] | 409 | |
---|
[3754] | 410 | $arr = &Mail_mimeDecode::getMimeNumbers($structure->parts[$i], $no_refs, $_mime_number, $prepend); |
---|
| 411 | foreach ($arr as $key => $val) { |
---|
| 412 | $no_refs ? $return[$key] = '' : $return[$key] = &$arr[$key]; |
---|
| 413 | } |
---|
| 414 | } |
---|
| 415 | } else { |
---|
| 416 | if ($mime_number == '') { |
---|
| 417 | $mime_number = '1'; |
---|
| 418 | } |
---|
| 419 | $structure->mime_id = $prepend . $mime_number; |
---|
| 420 | $no_refs ? $return[$prepend . $mime_number] = '' : $return[$prepend . $mime_number] = &$structure; |
---|
| 421 | } |
---|
[3637] | 422 | |
---|
[3754] | 423 | return $return; |
---|
| 424 | } |
---|
[3637] | 425 | |
---|
[3754] | 426 | /** |
---|
| 427 | * Given a string containing a header and body |
---|
| 428 | * section, this function will split them (at the first |
---|
| 429 | * blank line) and return them. |
---|
| 430 | * |
---|
| 431 | * @param string Input to split apart |
---|
| 432 | * @return array Contains header and body section |
---|
| 433 | * @access private |
---|
| 434 | */ |
---|
| 435 | function _splitBodyHeader($input) |
---|
| 436 | { |
---|
| 437 | if (preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $input, $match)) { |
---|
| 438 | return array($match[1], $match[2]); |
---|
| 439 | } |
---|
| 440 | $this->_error = 'Could not split header and body'; |
---|
| 441 | return false; |
---|
| 442 | } |
---|
[3637] | 443 | |
---|
[3754] | 444 | /** |
---|
| 445 | * Parse headers given in $input and return |
---|
| 446 | * as assoc array. |
---|
| 447 | * |
---|
| 448 | * @param string Headers to parse |
---|
| 449 | * @return array Contains parsed headers |
---|
| 450 | * @access private |
---|
| 451 | */ |
---|
| 452 | function _parseHeaders($input) |
---|
| 453 | { |
---|
[3637] | 454 | |
---|
[3754] | 455 | if ($input !== '') { |
---|
| 456 | // Unfold the input |
---|
| 457 | $input = preg_replace("/\r?\n/", "\r\n", $input); |
---|
| 458 | $input = preg_replace("/\r\n(\t| )+/", ' ', $input); |
---|
| 459 | $headers = explode("\r\n", trim($input)); |
---|
| 460 | |
---|
| 461 | foreach ($headers as $value) { |
---|
| 462 | $hdr_name = substr($value, 0, $pos = strpos($value, ':')); |
---|
| 463 | $hdr_value = substr($value, $pos+1); |
---|
| 464 | if($hdr_value[0] == ' ') |
---|
| 465 | $hdr_value = substr($hdr_value, 1); |
---|
| 466 | |
---|
| 467 | $return[] = array( |
---|
[3637] | 468 | 'name' => $hdr_name, |
---|
| 469 | 'value' => $this->_decode_headers ? $this->_decodeHeader($hdr_value) : $hdr_value |
---|
[3754] | 470 | ); |
---|
| 471 | } |
---|
| 472 | } else { |
---|
| 473 | $return = array(); |
---|
| 474 | } |
---|
[3637] | 475 | |
---|
[3754] | 476 | return $return; |
---|
| 477 | } |
---|
[3637] | 478 | |
---|
[3754] | 479 | /** |
---|
| 480 | * Function to parse a header value, |
---|
| 481 | * extract first part, and any secondary |
---|
| 482 | * parts (after ;) This function is not as |
---|
| 483 | * robust as it could be. Eg. header comments |
---|
| 484 | * in the wrong place will probably break it. |
---|
| 485 | * |
---|
| 486 | * @param string Header value to parse |
---|
| 487 | * @return array Contains parsed result |
---|
| 488 | * @access private |
---|
| 489 | */ |
---|
| 490 | function _parseHeaderValue($input) |
---|
| 491 | { |
---|
[3637] | 492 | |
---|
[3754] | 493 | if (($pos = strpos($input, ';')) !== false) { |
---|
[3637] | 494 | |
---|
[3754] | 495 | $return['value'] = trim(substr($input, 0, $pos)); |
---|
| 496 | $input = trim(substr($input, $pos+1)); |
---|
[3637] | 497 | |
---|
[3754] | 498 | if (strlen($input) > 0) { |
---|
[3637] | 499 | |
---|
[3754] | 500 | // This splits on a semi-colon, if there's no preceeding backslash |
---|
| 501 | // Now works with quoted values; had to glue the \; breaks in PHP |
---|
| 502 | // the regex is already bordering on incomprehensible |
---|
| 503 | //$splitRegex = '/([^;\'"]*[\'"]([^\'"]*([^\'"]*)*)[\'"][^;\'"]*|([^;]+))(;|$)/'; |
---|
| 504 | // simplyfied RegEx - Nokia Mail2 sends boundaries containing ' which break the above regex |
---|
| 505 | $splitRegex = '/([^;\'"]*[\'"]([^\'"]*)[\'"][^;\'"]*|([^;]+))(;|$)/'; |
---|
| 506 | preg_match_all($splitRegex, $input, $matches); |
---|
[3637] | 507 | |
---|
[3754] | 508 | $parameters = array(); |
---|
| 509 | for ($i=0; $i<count($matches[0]); $i++) { |
---|
| 510 | $param = $matches[0][$i]; |
---|
| 511 | while (substr($param, -2) == '\;') { |
---|
| 512 | $param .= $matches[0][++$i]; |
---|
| 513 | } |
---|
| 514 | $parameters[] = $param; |
---|
| 515 | } |
---|
[3637] | 516 | |
---|
[3754] | 517 | for ($i = 0; $i < count($parameters); $i++) { |
---|
| 518 | $param_name = trim(substr($parameters[$i], 0, $pos = strpos($parameters[$i], '=')), "'\";\t\\ "); |
---|
| 519 | $param_value = trim(str_replace('\;', ';', substr($parameters[$i], $pos + 1)), "'\";\t\\ "); |
---|
| 520 | if (!empty($param_value[0]) && $param_value[0] == '"') { |
---|
| 521 | $param_value = substr($param_value, 1, -1); |
---|
| 522 | } |
---|
| 523 | $return['other'][$param_name] = $param_value; |
---|
| 524 | $return['other'][strtolower($param_name)] = $param_value; |
---|
| 525 | } |
---|
| 526 | } |
---|
| 527 | } else { |
---|
| 528 | $return['value'] = trim($input); |
---|
| 529 | } |
---|
[3637] | 530 | |
---|
[3754] | 531 | return $return; |
---|
| 532 | } |
---|
[3637] | 533 | |
---|
[3754] | 534 | /** |
---|
| 535 | * This function splits the input based |
---|
| 536 | * on the given boundary |
---|
| 537 | * |
---|
| 538 | * @param string Input to parse |
---|
| 539 | * @return array Contains array of resulting mime parts |
---|
| 540 | * @access private |
---|
| 541 | */ |
---|
| 542 | function _boundarySplit($input, $boundary) |
---|
| 543 | { |
---|
| 544 | $parts = array(); |
---|
[3637] | 545 | |
---|
[3754] | 546 | $bs_possible = substr($boundary, 2, -2); |
---|
| 547 | $bs_check = '\"' . $bs_possible . '\"'; |
---|
[3637] | 548 | |
---|
[3754] | 549 | if ($boundary == $bs_check) { |
---|
| 550 | $boundary = $bs_possible; |
---|
| 551 | } |
---|
[3637] | 552 | |
---|
[3754] | 553 | $tmp = explode('--' . $boundary, $input); |
---|
[3637] | 554 | |
---|
[3754] | 555 | for ($i = 1; $i < count($tmp) - 1; $i++) { |
---|
| 556 | $parts[] = $tmp[$i]; |
---|
| 557 | } |
---|
[3637] | 558 | |
---|
[3754] | 559 | return $parts; |
---|
| 560 | } |
---|
[3637] | 561 | |
---|
[3754] | 562 | /** |
---|
| 563 | * Given a header, this function will decode it |
---|
| 564 | * according to RFC2047. Probably not *exactly* |
---|
| 565 | * conformant, but it does pass all the given |
---|
| 566 | * examples (in RFC2047). |
---|
| 567 | * |
---|
| 568 | * @param string Input header value to decode |
---|
| 569 | * @return string Decoded header value |
---|
| 570 | * @access private |
---|
| 571 | */ |
---|
| 572 | function _decodeHeader($input) |
---|
| 573 | { |
---|
| 574 | // Remove white space between encoded-words |
---|
| 575 | $input = preg_replace('/(=\?[^?]+\?(q|b)\?[^?]*\?=)(\s)+=\?/i', '\1=?', $input); |
---|
[3637] | 576 | |
---|
[3754] | 577 | // For each encoded-word... |
---|
| 578 | while (preg_match('/(=\?([^?]+)\?(q|b)\?([^?]*)\?=)/i', $input, $matches)) { |
---|
[3637] | 579 | |
---|
[3754] | 580 | $encoded = $matches[1]; |
---|
| 581 | $charset = $matches[2]; |
---|
| 582 | $encoding = $matches[3]; |
---|
| 583 | $text = $matches[4]; |
---|
[3637] | 584 | |
---|
[3754] | 585 | switch (strtolower($encoding)) { |
---|
| 586 | case 'b': |
---|
| 587 | $text = base64_decode($text); |
---|
| 588 | break; |
---|
[3637] | 589 | |
---|
[3754] | 590 | case 'q': |
---|
| 591 | $text = str_replace('_', ' ', $text); |
---|
| 592 | preg_match_all('/=([a-f0-9]{2})/i', $text, $matches); |
---|
| 593 | foreach($matches[1] as $value) |
---|
| 594 | $text = str_replace('='.$value, chr(hexdec($value)), $text); |
---|
| 595 | break; |
---|
| 596 | } |
---|
[3637] | 597 | |
---|
[3754] | 598 | $input = str_replace($encoded, $this->_fromCharset($charset, $text), $input); |
---|
| 599 | } |
---|
[3637] | 600 | |
---|
[3754] | 601 | return $input; |
---|
| 602 | } |
---|
[3637] | 603 | |
---|
[3754] | 604 | /** |
---|
| 605 | * Given a body string and an encoding type, |
---|
| 606 | * this function will decode and return it. |
---|
| 607 | * |
---|
| 608 | * @param string Input body to decode |
---|
| 609 | * @param string Encoding type to use. |
---|
| 610 | * @return string Decoded body |
---|
| 611 | * @access private |
---|
| 612 | */ |
---|
| 613 | function _decodeBody($input, $encoding = '7bit', $charset = '') |
---|
| 614 | { |
---|
| 615 | switch (strtolower($encoding)) { |
---|
| 616 | case '7bit': |
---|
| 617 | return $this->_fromCharset($charset, $input);; |
---|
| 618 | break; |
---|
[3637] | 619 | |
---|
[3754] | 620 | case '8bit': |
---|
| 621 | return $this->_fromCharset($charset, $input); |
---|
| 622 | break; |
---|
[3637] | 623 | |
---|
[3754] | 624 | case 'quoted-printable': |
---|
| 625 | return $this->_fromCharset($charset, $this->_quotedPrintableDecode($input)); |
---|
| 626 | break; |
---|
[3637] | 627 | |
---|
[3754] | 628 | case 'base64': |
---|
| 629 | return $this->_fromCharset($charset, base64_decode($input)); |
---|
| 630 | break; |
---|
[3637] | 631 | |
---|
[3754] | 632 | default: |
---|
| 633 | return $input; |
---|
| 634 | } |
---|
| 635 | } |
---|
[3637] | 636 | |
---|
[3754] | 637 | /** |
---|
| 638 | * Given a quoted-printable string, this |
---|
| 639 | * function will decode and return it. |
---|
| 640 | * |
---|
| 641 | * @param string Input body to decode |
---|
| 642 | * @return string Decoded body |
---|
| 643 | * @access private |
---|
| 644 | */ |
---|
| 645 | function _quotedPrintableDecode($input) |
---|
| 646 | { |
---|
| 647 | // Remove soft line breaks |
---|
| 648 | $input = preg_replace("/=\r?\n/", '', $input); |
---|
[3637] | 649 | |
---|
[3754] | 650 | // Replace encoded characters |
---|
| 651 | $input = preg_replace('/=([a-f0-9]{2})/ie', "chr(hexdec('\\1'))", $input); |
---|
[3637] | 652 | |
---|
[3754] | 653 | return $input; |
---|
| 654 | } |
---|
[3637] | 655 | |
---|
[3754] | 656 | /** |
---|
| 657 | * Checks the input for uuencoded files and returns |
---|
| 658 | * an array of them. Can be called statically, eg: |
---|
| 659 | * |
---|
| 660 | * $files =& Mail_mimeDecode::uudecode($some_text); |
---|
| 661 | * |
---|
| 662 | * It will check for the begin 666 ... end syntax |
---|
| 663 | * however and won't just blindly decode whatever you |
---|
| 664 | * pass it. |
---|
| 665 | * |
---|
| 666 | * @param string Input body to look for attahcments in |
---|
| 667 | * @return array Decoded bodies, filenames and permissions |
---|
| 668 | * @access public |
---|
| 669 | * @author Unknown |
---|
| 670 | */ |
---|
| 671 | function &uudecode($input) |
---|
| 672 | { |
---|
| 673 | // Find all uuencoded sections |
---|
| 674 | preg_match_all("/begin ([0-7]{3}) (.+)\r?\n(.+)\r?\nend/Us", $input, $matches); |
---|
[3637] | 675 | |
---|
[3754] | 676 | for ($j = 0; $j < count($matches[3]); $j++) { |
---|
[3637] | 677 | |
---|
[3754] | 678 | $str = $matches[3][$j]; |
---|
| 679 | $filename = $matches[2][$j]; |
---|
| 680 | $fileperm = $matches[1][$j]; |
---|
[3637] | 681 | |
---|
[3754] | 682 | $file = ''; |
---|
| 683 | $str = preg_split("/\r?\n/", trim($str)); |
---|
| 684 | $strlen = count($str); |
---|
[3637] | 685 | |
---|
[3754] | 686 | for ($i = 0; $i < $strlen; $i++) { |
---|
| 687 | $pos = 1; |
---|
| 688 | $d = 0; |
---|
| 689 | $len=(int)(((ord(substr($str[$i],0,1)) -32) - ' ') & 077); |
---|
[3637] | 690 | |
---|
[3754] | 691 | while (($d + 3 <= $len) AND ($pos + 4 <= strlen($str[$i]))) { |
---|
| 692 | $c0 = (ord(substr($str[$i],$pos,1)) ^ 0x20); |
---|
| 693 | $c1 = (ord(substr($str[$i],$pos+1,1)) ^ 0x20); |
---|
| 694 | $c2 = (ord(substr($str[$i],$pos+2,1)) ^ 0x20); |
---|
| 695 | $c3 = (ord(substr($str[$i],$pos+3,1)) ^ 0x20); |
---|
| 696 | $file .= chr(((($c0 - ' ') & 077) << 2) | ((($c1 - ' ') & 077) >> 4)); |
---|
[3637] | 697 | |
---|
[3754] | 698 | $file .= chr(((($c1 - ' ') & 077) << 4) | ((($c2 - ' ') & 077) >> 2)); |
---|
[3637] | 699 | |
---|
[3754] | 700 | $file .= chr(((($c2 - ' ') & 077) << 6) | (($c3 - ' ') & 077)); |
---|
[3637] | 701 | |
---|
[3754] | 702 | $pos += 4; |
---|
| 703 | $d += 3; |
---|
| 704 | } |
---|
[3637] | 705 | |
---|
[3754] | 706 | if (($d + 2 <= $len) && ($pos + 3 <= strlen($str[$i]))) { |
---|
| 707 | $c0 = (ord(substr($str[$i],$pos,1)) ^ 0x20); |
---|
| 708 | $c1 = (ord(substr($str[$i],$pos+1,1)) ^ 0x20); |
---|
| 709 | $c2 = (ord(substr($str[$i],$pos+2,1)) ^ 0x20); |
---|
| 710 | $file .= chr(((($c0 - ' ') & 077) << 2) | ((($c1 - ' ') & 077) >> 4)); |
---|
[3637] | 711 | |
---|
[3754] | 712 | $file .= chr(((($c1 - ' ') & 077) << 4) | ((($c2 - ' ') & 077) >> 2)); |
---|
[3637] | 713 | |
---|
[3754] | 714 | $pos += 3; |
---|
| 715 | $d += 2; |
---|
| 716 | } |
---|
[3637] | 717 | |
---|
[3754] | 718 | if (($d + 1 <= $len) && ($pos + 2 <= strlen($str[$i]))) { |
---|
| 719 | $c0 = (ord(substr($str[$i],$pos,1)) ^ 0x20); |
---|
| 720 | $c1 = (ord(substr($str[$i],$pos+1,1)) ^ 0x20); |
---|
| 721 | $file .= chr(((($c0 - ' ') & 077) << 2) | ((($c1 - ' ') & 077) >> 4)); |
---|
[3637] | 722 | |
---|
[3754] | 723 | } |
---|
| 724 | } |
---|
| 725 | $files[] = array('filename' => $filename, 'fileperm' => $fileperm, 'filedata' => $file); |
---|
| 726 | } |
---|
[3637] | 727 | |
---|
[3754] | 728 | return $files; |
---|
| 729 | } |
---|
[3637] | 730 | |
---|
[3754] | 731 | /** |
---|
| 732 | * getSendArray() returns the arguments required for Mail::send() |
---|
| 733 | * used to build the arguments for a mail::send() call |
---|
| 734 | * |
---|
| 735 | * Usage: |
---|
| 736 | * $mailtext = Full email (for example generated by a template) |
---|
| 737 | * $decoder = new Mail_mimeDecode($mailtext); |
---|
| 738 | * $parts = $decoder->getSendArray(); |
---|
| 739 | * if (!PEAR::isError($parts) { |
---|
| 740 | * list($recipents,$headers,$body) = $parts; |
---|
| 741 | * $mail = Mail::factory('smtp'); |
---|
| 742 | * $mail->send($recipents,$headers,$body); |
---|
| 743 | * } else { |
---|
| 744 | * echo $parts->message; |
---|
| 745 | * } |
---|
| 746 | * @return mixed array of recipeint, headers,body or Pear_Error |
---|
| 747 | * @access public |
---|
| 748 | * @author Alan Knowles <alan@akbkhome.com> |
---|
| 749 | */ |
---|
| 750 | function getSendArray() |
---|
| 751 | { |
---|
| 752 | // prevent warning if this is not set |
---|
| 753 | $this->_decode_headers = FALSE; |
---|
| 754 | $headerlist =$this->_parseHeaders($this->_header); |
---|
| 755 | $to = ""; |
---|
| 756 | if (!$headerlist) { |
---|
| 757 | return $this->raiseError("Message did not contain headers"); |
---|
| 758 | } |
---|
| 759 | foreach($headerlist as $item) { |
---|
| 760 | $header[$item['name']] = $item['value']; |
---|
| 761 | switch (strtolower($item['name'])) { |
---|
| 762 | case "to": |
---|
| 763 | case "cc": |
---|
| 764 | case "bcc": |
---|
| 765 | $to .= ",".$item['value']; |
---|
| 766 | default: |
---|
| 767 | break; |
---|
| 768 | } |
---|
| 769 | } |
---|
| 770 | if ($to == "") { |
---|
| 771 | return $this->raiseError("Message did not contain any recipents"); |
---|
| 772 | } |
---|
| 773 | $to = substr($to,1); |
---|
| 774 | return array($to,$header,$this->_body); |
---|
| 775 | } |
---|
| 776 | |
---|
| 777 | /** |
---|
| 778 | * Returns a xml copy of the output of |
---|
| 779 | * Mail_mimeDecode::decode. Pass the output in as the |
---|
| 780 | * argument. This function can be called statically. Eg: |
---|
| 781 | * |
---|
| 782 | * $output = $obj->decode(); |
---|
| 783 | * $xml = Mail_mimeDecode::getXML($output); |
---|
| 784 | * |
---|
| 785 | * The DTD used for this should have been in the package. Or |
---|
| 786 | * alternatively you can get it from cvs, or here: |
---|
| 787 | * http://www.phpguru.org/xmail/xmail.dtd. |
---|
| 788 | * |
---|
| 789 | * @param object Input to convert to xml. This should be the |
---|
| 790 | * output of the Mail_mimeDecode::decode function |
---|
| 791 | * @return string XML version of input |
---|
| 792 | * @access public |
---|
| 793 | */ |
---|
| 794 | function getXML($input) |
---|
| 795 | { |
---|
| 796 | $crlf = "\r\n"; |
---|
| 797 | $output = '<?xml version=\'1.0\'?>' . $crlf . |
---|
[3637] | 798 | '<!DOCTYPE email SYSTEM "http://www.phpguru.org/xmail/xmail.dtd">' . $crlf . |
---|
| 799 | '<email>' . $crlf . |
---|
[3754] | 800 | Mail_mimeDecode::_getXML($input) . |
---|
[3637] | 801 | '</email>'; |
---|
| 802 | |
---|
[3754] | 803 | return $output; |
---|
| 804 | } |
---|
[3637] | 805 | |
---|
[3754] | 806 | /** |
---|
| 807 | * Function that does the actual conversion to xml. Does a single |
---|
| 808 | * mimepart at a time. |
---|
| 809 | * |
---|
| 810 | * @param object Input to convert to xml. This is a mimepart object. |
---|
| 811 | * It may or may not contain subparts. |
---|
| 812 | * @param integer Number of tabs to indent |
---|
| 813 | * @return string XML version of input |
---|
| 814 | * @access private |
---|
| 815 | */ |
---|
| 816 | function _getXML($input, $indent = 1) |
---|
| 817 | { |
---|
| 818 | $htab = "\t"; |
---|
| 819 | $crlf = "\r\n"; |
---|
| 820 | $output = ''; |
---|
| 821 | $headers = @(array)$input->headers; |
---|
[3637] | 822 | |
---|
[3754] | 823 | foreach ($headers as $hdr_name => $hdr_value) { |
---|
[3637] | 824 | |
---|
[3754] | 825 | // Multiple headers with this name |
---|
| 826 | if (is_array($headers[$hdr_name])) { |
---|
| 827 | for ($i = 0; $i < count($hdr_value); $i++) { |
---|
| 828 | $output .= Mail_mimeDecode::_getXML_helper($hdr_name, $hdr_value[$i], $indent); |
---|
| 829 | } |
---|
[3637] | 830 | |
---|
[3754] | 831 | // Only one header of this sort |
---|
| 832 | } else { |
---|
| 833 | $output .= Mail_mimeDecode::_getXML_helper($hdr_name, $hdr_value, $indent); |
---|
| 834 | } |
---|
| 835 | } |
---|
[3637] | 836 | |
---|
[3754] | 837 | if (!empty($input->parts)) { |
---|
| 838 | for ($i = 0; $i < count($input->parts); $i++) { |
---|
| 839 | $output .= $crlf . str_repeat($htab, $indent) . '<mimepart>' . $crlf . |
---|
| 840 | Mail_mimeDecode::_getXML($input->parts[$i], $indent+1) . |
---|
| 841 | str_repeat($htab, $indent) . '</mimepart>' . $crlf; |
---|
| 842 | } |
---|
| 843 | } elseif (isset($input->body)) { |
---|
| 844 | $output .= $crlf . str_repeat($htab, $indent) . '<body><![CDATA[' . |
---|
| 845 | $input->body . ']]></body>' . $crlf; |
---|
| 846 | } |
---|
[3637] | 847 | |
---|
[3754] | 848 | return $output; |
---|
| 849 | } |
---|
[3637] | 850 | |
---|
[3754] | 851 | /** |
---|
| 852 | * Helper function to _getXML(). Returns xml of a header. |
---|
| 853 | * |
---|
| 854 | * @param string Name of header |
---|
| 855 | * @param string Value of header |
---|
| 856 | * @param integer Number of tabs to indent |
---|
| 857 | * @return string XML version of input |
---|
| 858 | * @access private |
---|
| 859 | */ |
---|
| 860 | function _getXML_helper($hdr_name, $hdr_value, $indent) |
---|
| 861 | { |
---|
| 862 | $htab = "\t"; |
---|
| 863 | $crlf = "\r\n"; |
---|
| 864 | $return = ''; |
---|
[3637] | 865 | |
---|
[3754] | 866 | $new_hdr_value = ($hdr_name != 'received') ? Mail_mimeDecode::_parseHeaderValue($hdr_value) : array('value' => $hdr_value); |
---|
| 867 | $new_hdr_name = str_replace(' ', '-', ucwords(str_replace('-', ' ', $hdr_name))); |
---|
[3637] | 868 | |
---|
[3754] | 869 | // Sort out any parameters |
---|
| 870 | if (!empty($new_hdr_value['other'])) { |
---|
| 871 | foreach ($new_hdr_value['other'] as $paramname => $paramvalue) { |
---|
| 872 | $params[] = str_repeat($htab, $indent) . $htab . '<parameter>' . $crlf . |
---|
| 873 | str_repeat($htab, $indent) . $htab . $htab . '<paramname>' . htmlspecialchars($paramname) . '</paramname>' . $crlf . |
---|
| 874 | str_repeat($htab, $indent) . $htab . $htab . '<paramvalue>' . htmlspecialchars($paramvalue) . '</paramvalue>' . $crlf . |
---|
| 875 | str_repeat($htab, $indent) . $htab . '</parameter>' . $crlf; |
---|
| 876 | } |
---|
[3637] | 877 | |
---|
[3754] | 878 | $params = implode('', $params); |
---|
| 879 | } else { |
---|
| 880 | $params = ''; |
---|
| 881 | } |
---|
[3637] | 882 | |
---|
[3754] | 883 | $return = str_repeat($htab, $indent) . '<header>' . $crlf . |
---|
| 884 | str_repeat($htab, $indent) . $htab . '<headername>' . htmlspecialchars($new_hdr_name) . '</headername>' . $crlf . |
---|
| 885 | str_repeat($htab, $indent) . $htab . '<headervalue>' . htmlspecialchars($new_hdr_value['value']) . '</headervalue>' . $crlf . |
---|
| 886 | $params . |
---|
| 887 | str_repeat($htab, $indent) . '</header>' . $crlf; |
---|
[3637] | 888 | |
---|
[3754] | 889 | return $return; |
---|
| 890 | } |
---|
[3637] | 891 | |
---|
[3754] | 892 | /** |
---|
| 893 | * Z-Push helper to decode text |
---|
| 894 | * |
---|
| 895 | * @param string current charset of input |
---|
| 896 | * @param string input |
---|
| 897 | * @return string XML version of input |
---|
| 898 | * @access private |
---|
| 899 | */ |
---|
| 900 | function _fromCharset($charset, $input) { |
---|
| 901 | if($charset == '' || ($charset == $this->_charset)) |
---|
[3637] | 902 | return $input; |
---|
| 903 | |
---|
| 904 | return @iconv($charset, $this->_charset. "//TRANSLIT", $input); |
---|
[3754] | 905 | } |
---|
| 906 | |
---|
| 907 | /** |
---|
| 908 | * Z-Push helper for error logging |
---|
| 909 | * removing PEAR dependency |
---|
| 910 | * |
---|
| 911 | * @param string debug message |
---|
| 912 | * @return boolean always false as there was an error |
---|
| 913 | * @access private |
---|
| 914 | */ |
---|
| 915 | function raiseError($message) { |
---|
| 916 | debugLog("mimeDecode error: ". $message); |
---|
| 917 | return false; |
---|
| 918 | } |
---|
[3637] | 919 | } // End of class |
---|