source: trunk/library/mime/mimeDecode.php @ 7673

Revision 7673, 36.5 KB checked in by douglasz, 9 years ago (diff)

Ticket #3236 - Correcoes para Performance: Function Within Loop Declaration.

  • Property svn:executable set to *
Line 
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 */
91class 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']);
328                    $parts_count = count($parts);
329                    for ($i = 0; $i < $parts_count; ++$i) {
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            }
389            $structure_parts_count = count($structure->parts);
390            for ($i = 0; $i < $structure_parts_count; ++$i) {
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 == '\\') {
524                ++$i;
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);
538                    ++$i;
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;
550                ++$i;
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") {
559                    ++$i;
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);
568                    ++$i;
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;
596                    ++$i;
597                    continue;
598                }
599
600                $val .= $c;
601                ++$i;
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;
611                ++$i;
612                continue;
613            }
614               
615            // normal char inside of quoted string..
616            $val.= $c;
617            ++$i;
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        }
668        $tmp = preg_split("/--".preg_quote($boundary, '/')."((?=\s)|--)/", $input);
669
670        $len = count($tmp) -1;
671        for ($i = 1; $i < $len; ++$i) {
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
795        $matches_count = count($matches[3]);
796        for ($j = 0; $j < $matches_count; ++$j) {
797
798            $str      = $matches[3][$j];
799            $filename = $matches[2][$j];
800            $fileperm = $matches[1][$j];
801
802            $file = '';
803            $str = preg_split('/\r?\n/', trim($str));
804            $strlen = count($str);
805
806            for ($i = 0; $i < $strlen; ++$i) {
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])) {
947                $hdr_value_count = count($hdr_value);
948                for ($i = 0; $i < $hdr_value_count; ++$i) {
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)) {
959            $parts_count = count($input->parts);
960            for ($i = 0; $i < $parts_count; ++$i) {
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
Note: See TracBrowser for help on using the repository browser.