A few changes, mostly to make the code more readable. In
[squirrelmail.git] / class / mime.class.php
1 <?php
2
3 /**
4 * mime.class
5 *
6 * Copyright (c) 2002 The SquirrelMail Project Team
7 * Licensed under the GNU GPL. For full terms see the file COPYING.
8 *
9 *
10 * This contains functions needed to handle mime messages.
11 *
12 * $Id$
13 */
14
15
16
17 /*
18 * rdc822_header class
19 * input: header_string or array
20 */
21 class rfc822_header
22 {
23 var $date = '',
24 $subject = '',
25 $from = array(),
26 $sender = '',
27 $reply_to = array(),
28 $to = array(),
29 $cc = array(),
30 $bcc = array(),
31 $in_reply_to = '',
32 $message_id = '',
33 $mime = false,
34 $content_type = '',
35 $disposition = '',
36 $xmailer = '',
37 $priority = 3,
38 $dnt = '',
39 $mlist = array(),
40 $more_headers = array(); /* only needed for constructing headers
41 in smtp.php */
42
43 function parseHeader($hdr)
44 {
45 if (is_array($hdr))
46 {
47 $hdr = implode('',$hdr);
48 }
49 /* first we unfold the header */
50 $hdr = trim(str_replace(array("\r\n\t","\r\n "),array('',''),$hdr));
51 /*
52 * now we can make a new header array with each element representing
53 * a headerline
54 */
55 $hdr = explode("\r\n" , $hdr);
56 foreach ($hdr as $line)
57 {
58 $pos = strpos($line,':');
59 if ($pos > 0)
60 {
61 $field = substr($line,0,$pos);
62 $value = trim(substr($line,$pos+1));
63 if(!preg_match('/^X.*/i',$field)) {
64 $value = $this->stripComments($value);
65 }
66 $this->parseField($field,$value);
67 }
68 }
69 if ($this->content_type == '')
70 {
71 $this->parseContentType('text/plain; charset=us-ascii');
72 }
73 }
74
75 function stripComments($value)
76 {
77 $cnt = strlen($value);
78 $s = '';
79 $i = 0;
80 while ($i < $cnt)
81 {
82 switch ($value{$i})
83 {
84 case ('"'):
85 $s .= '"';
86 $i++;
87 while ($value{$i} != '"')
88 {
89 if ($value{$i} == '\\')
90 {
91 $s .= '\\';
92 $i++;
93 }
94 $s .= $value{$i};
95 $i++;
96 if ($i > $cnt) break;
97 }
98 $s .= $value{$i};
99 break;
100 case ('('):
101 while ($value{$i} != ')')
102 {
103 if ($value{$i} == '\\')
104 {
105 $i++;
106 }
107 $i++;
108 }
109 break;
110 default:
111 $s .= $value{$i};
112 break;
113 }
114 $i++;
115 }
116 return $s;
117 }
118
119 function parseField($field,$value)
120 {
121 $field = strtolower($field);
122 switch($field)
123 {
124 case ('date'):
125 $d = strtr($value, array(' ' => ' '));
126 $d = explode(' ', $d);
127 $this->date = getTimeStamp($d);
128 break;
129 case ('subject'):
130 $this->subject = $value;
131 break;
132 case ('from'):
133 $this->from = $this->parseAddress($value,true);
134 break;
135 case ('sender'):
136 $this->sender = $this->parseAddress($value);
137 break;
138 case ('reply-to'):
139 $this->reply_to = $this->parseAddress($value, true);
140 break;
141 case ('to'):
142 $this->to = $this->parseAddress($value, true);
143 break;
144 case ('cc'):
145 $this->cc = $this->parseAddress($value, true);
146 break;
147 case ('bcc'):
148 $this->bcc = $this->parseAddress($value, true);
149 break;
150 case ('in-reply-to'):
151 $this->in_reply_to = $value;
152 break;
153 case ('message_id'):
154 $this->message_id = $value;
155 break;
156 case ('disposition-notification-to'):
157 $this->dnt = $this->parseAddress($value);
158 break;
159 case ('mime-Version'):
160 $value = str_replace(' ','',$value);
161 if ($value == '1.0')
162 {
163 $this->mime = true;
164 }
165 break;
166 case ('content-type'):
167 $this->parseContentType($value);
168 break;
169 case ('content-disposition'):
170 $this->parseDisposition($value);
171 break;
172 case ('x-mailer'):
173 $this->xmailer = $value;
174 break;
175 case ('x-priority'):
176 $this->priority = $value;
177 break;
178 case ('list-post'):
179 $this->mlist('post',$value);
180 break;
181 case ('list-reply'):
182 $this->mlist('reply',$value);
183 break;
184 case ('list-subscribe'):
185 $this->mlist('subscribe',$value);
186 break;
187 case ('list-unsubscribe'):
188 $this->mlist('unsubscribe',$value);
189 break;
190 case ('list-archive'):
191 $this->mlist('archive',$value);
192 break;
193 case ('list-owner'):
194 $this->mlist('owner',$value);
195 break;
196 case ('list-help'):
197 $this->mlist('help',$value);
198 break;
199 case ('list-id'):
200 $this->mlist('id',$value);
201 break;
202 default:
203 break;
204 }
205 }
206
207 function parseAddress($address, $ar=false, $addr_ar = array(), $group = '')
208 {
209 $pos = 0;
210 $j = strlen( $address );
211 $name = '';
212 $addr = '';
213 while ( $pos < $j ) {
214 switch ($address{$pos})
215 {
216 case ('"'): /* get the personal name */
217 $pos++;
218 if ($address{$pos} == '"')
219 {
220 $pos++;
221 } else
222 {
223 while ( $pos < $j && $address{$pos} != '"')
224 {
225 if (substr($address, $pos, 2) == '\\"')
226 {
227 $name .= $address{$pos};
228 $pos++;
229 } elseif (substr($address, $pos, 2) == '\\\\')
230 {
231 $name .= $address{$pos};
232 $pos++;
233 }
234 $name .= $address{$pos};
235 $pos++;
236 }
237 }
238 $pos++;
239 break;
240 case ('<'): /* get email address */
241 $addr_start=$pos;
242 $pos++;
243 while ( $pos < $j && $address{$pos} != '>' )
244 {
245 $addr .= $address{$pos};
246 $pos++;
247 }
248 $pos++;
249 break;
250 case ('('): /* rip off comments */
251 $addr_start=$pos;
252 $pos++;
253 while ( $pos < $j && $address{$pos} != ')' )
254 {
255 $addr .= $address{$pos};
256 $pos++;
257 }
258 $address_start = substr($address,0,$addr_start);
259 $address_end = substr($address,$pos+1);
260 $address = $address_start . $address_end;
261 $j = strlen( $address );
262 $pos = $addr_start;
263 $pos++;
264 break;
265 case (','): /* we reached a delimiter */
266 if ($addr == '')
267 {
268 $addr = substr($address,0,$pos);
269 } elseif ($name == '') {
270 $name = trim(substr($address,0,$addr_start));
271 }
272
273 $at = strpos($addr, '@');
274 $addr_structure = new address_structure();
275 $addr_structure->personal = $name;
276 $addr_structure->group = $group;
277 if ($at)
278 {
279 $addr_structure->mailbox = substr($addr,0,$at);
280 $addr_structure->host = substr($addr,$at+1);
281 } else
282 {
283 $addr_structure->mailbox = $addr;
284 }
285 $address = trim(substr($address,$pos+1));
286 $j = strlen( $address );
287 $pos = 0;
288 $name = '';
289 $addr = '';
290 $addr_ar[] = $addr_structure;
291 break;
292 case (':'): /* process the group addresses */
293 /* group marker */
294 $group = substr($address,0,$pos);
295 $address = substr($address,$pos+1);
296 $result = $this->parseAddress($address, $ar, $addr_ar, $group);
297 $addr_ar = $result[0];
298 $pos = $result[1];
299 $address = substr($address,$pos);
300 $j = strlen( $address );
301 $group = '';
302 $pos++;
303 break;
304 case (';'):
305 if ($group)
306 {
307 $address = substr($address, 0, $pos-1);
308 }
309 $pos++;
310 break;
311 default:
312 $pos++;
313 break;
314 }
315
316 }
317 if ($addr == '')
318 {
319 $addr = substr($address,0,$pos);
320 } elseif ($name == '')
321 {
322 $name = trim(substr($address,0,$addr_start));
323 }
324 $at = strpos($addr, '@');
325 $addr_structure = new address_structure();
326 $addr_structure->group = $group;
327 if ($at)
328 {
329 $addr_structure->mailbox = trim(substr($addr,0,$at));
330 $addr_structure->host = trim(substr($addr,$at+1));
331 } else
332 {
333 $addr_structure->mailbox = trim($addr);
334 }
335 if ($group && $addr == '') /* no addresses found in group */
336 {
337 $name = "$group: Undisclosed recipients;";
338 $addr_structure->personal = $name;
339 $addr_ar[] = $addr_structure;
340 return (array($addr_ar,$pos+1));
341 } else
342 {
343 $addr_structure->personal = $name;
344 if ($name || $addr)
345 {
346 $addr_ar[] = $addr_structure;
347 }
348 }
349 if ($ar)
350 {
351 return ($addr_ar);
352 } else
353 {
354 return ($addr_ar[0]);
355 }
356 }
357
358 function parseContentType($value)
359 {
360 $pos = strpos($value,';');
361 $props = '';
362 if ($pos > 0)
363 {
364 $type = trim(substr($value,0,$pos));
365 $props = trim(substr($type,$pos+1));
366 } else
367 {
368 $type = $value;
369 }
370 $content_type = new content_type($type);
371 if ($props)
372 {
373 $properties = $this->parseProperties($props);
374 if (!isset($properties['charset']))
375 {
376 $properties['charset'] = 'us-ascii';
377 }
378 $content_type->properties = $this->parseProperties($props);
379 }
380 $this->content_type = $content_type;
381 }
382
383 function parseProperties($value)
384 {
385 $propArray = explode(';',$value);
386 $propResultArray = array();
387 foreach ($propArray as $prop)
388 {
389 $prop = trim($prop);
390 $pos = strpos($prop,'=');
391 if ($pos>0)
392 {
393 $key = trim(substr($prop,0,$pos));
394 $val = trim(substr($prop,$pos+1));
395 if ($val{0} == '"')
396 {
397 $val = substr($val,1,-1);
398 }
399 $propResultArray[$key] = $val;
400 }
401 }
402 return $propResultArray;
403 }
404
405 function parseDisposition($value)
406 {
407 $pos = strpos($value,';');
408 $props = '';
409 if ($pos > 0)
410 {
411 $name = trim(substr($value,0,$pos));
412 $props = trim(substr($type,$pos+1));
413 } else
414 {
415 $name = $value;
416 }
417 $props_a = $this->parseProperties($props);
418 $disp = new disposition($name);
419 $disp->properties = $props_a;
420 $this->disposition = $disp;
421 }
422
423 function mlist($field, $value)
424 {
425 $res_a = array();
426 $value_a = explode(',',$value);
427 foreach ($value_a as $val) {
428 $val = trim($val);
429 if ($val{0} == '<')
430 {
431 $val = substr($val,1,-1);
432 }
433 if (substr($val,0,7) == 'mailto:')
434 {
435 $res_a['mailto'] = substr($val,7);
436 } else
437 {
438 $res_a['href'] = $val;
439 }
440 }
441 $this->mlist[$field] = $res_a;
442 }
443
444 /*
445 * function to get the addres strings out of the header.
446 * Arguments: string or array of strings !
447 * example1: header->getAddr_s('to').
448 * example2: header->getAddr_s(array('to','cc','bcc'))
449 */
450 function getAddr_s($arr, $separator=', ')
451 {
452 if (is_array($arr))
453 {
454 $s = '';
455 foreach($arr as $arg )
456 {
457 $result = $this->getAddr_s($arg);
458 if ($result)
459 {
460 $s .= $separator . $result;
461 }
462 }
463 if ($s) $s = substr($s,2);
464 return $s;
465 } else
466 {
467 $s = '';
468 eval('$addr = $this->'.$arr.';') ;
469 if (is_array($addr))
470 {
471 foreach ($addr as $addr_o)
472 {
473 if (is_object($addr_o))
474 {
475 $s .= $addr_o->getAddress() . $separator;
476 }
477 }
478 $s = substr($s,0,-strlen($separator));
479 } else
480 {
481 if (is_object($addr))
482 {
483 $s .= $addr->getAddress();
484 }
485 }
486 return $s;
487 }
488 }
489
490 function getAddr_a($arg, $excl_arr=array(), $arr = array())
491 {
492 if (is_array($arg))
493 {
494 foreach($arg as $argument )
495 {
496 $arr = $this->getAddr_a($argument, $excl_arr, $arr);
497 }
498 return $arr;
499 } else
500 {
501 eval('$addr = $this->'.$arg.';') ;
502 if (is_array($addr))
503 {
504 foreach ($addr as $addr_o)
505 {
506 if (is_object($addr_o))
507 {
508 if (isset($addr_o->host) && $addr_o->host !='')
509 {
510 $email = $addr_o->mailbox.'@'.$addr_o->host;
511 } else
512 {
513 $email = $addr_o->mailbox;
514 }
515 $email = strtolower($email);
516 if ($email && !isset($arr[$email]) && !isset($excl_arr[$email]))
517 {
518 $arr[$email] = $addr_o->personal;
519 }
520 }
521 }
522 } else
523 {
524 if (is_object($addr))
525 {
526 if (isset($addr->host))
527 {
528 $email = $addr->mailbox.'@'.$addr->host;
529 } else
530 {
531 $email = $addr->mailbox;
532 }
533 $email = strtolower($email);
534 if ($email && !isset($arr[$email]) && !isset($excl_arr[$email]))
535 {
536 $arr[$email] = $addr->personal;
537 }
538 }
539 }
540 return $arr;
541 }
542 }
543
544 function getContentType($type0, $type1)
545 {
546 $type0 = $this->content_type->type0;
547 $type1 = $this->content_type->type1;
548 return $this->content_type->properties;
549 }
550 }
551
552 class msg_header
553 {
554 /** msg_header contains all variables available in a bodystructure **/
555 /** entity like described in rfc2060 **/
556
557 var $type0 = '',
558 $type1 = '',
559 $parameters = array(),
560 $id = 0,
561 $description = '',
562 $encoding='',
563 $size = 0,
564 $md5='',
565 $disposition = '',
566 $language='';
567
568 /*
569 * returns addres_list of supplied argument
570 * arguments: array('to', 'from', ...) or just a string like 'to'.
571 * result: string: address1, addres2, ....
572 */
573
574 function setVar($var, $value)
575 {
576 $this->{$var} = $value;
577 }
578
579 function getParameter($par)
580 {
581 $value = strtolower($par);
582 if (isset($this->parameters[$par]))
583 {
584 return $this->parameters[$par];
585 }
586 return '';
587 }
588
589 function setParameter($parameter, $value)
590 {
591 $this->parameters[strtolower($parameter)] = $value;
592 }
593 }
594
595
596
597 class address_structure
598 {
599 var $personal = '', $adl = '', $mailbox = '', $host = '', $group = '';
600
601 function getAddress($full=true)
602 {
603 if (is_object($this))
604 {
605 if (isset($this->host) && $this->host !='')
606 {
607 $email = $this->mailbox.'@'.$this->host;
608 } else
609 {
610 $email = $this->mailbox;
611 }
612 if (trim($this->personal) !='')
613 {
614 if ($email)
615 {
616 $addr = '"' . $this->personal . '" <' .$email.'>';
617 } else
618 {
619 $addr = $this->personal;
620 }
621 $best_dpl = $this->personal;
622 } else
623 {
624 $addr = $email;
625 $best_dpl = $email;
626 }
627 if ($full)
628 {
629 return $addr;
630 } else
631 {
632 return $best_dpl;
633 }
634 } else return '';
635 }
636 }
637
638 class message
639 {
640 /** message is the object that contains messages. It is a recursive
641 object in that through the $entities variable, it can contain
642 more objects of type message. See documentation in mime.txt for
643 a better description of how this works.
644 **/
645 var $rfc822_header = '',
646 $mime_header = '',
647 $flags = '',
648 $type0='',
649 $type1='',
650 $entities = array(),
651 $parent_ent, $entity,
652 $parent = '', $decoded_body='',
653 $is_seen = 0, $is_answered = 0, $is_deleted = 0, $is_flagged = 0,
654 $is_mdnsent = 0,
655 $body_part = '',
656 $offset = 0, /* for fetching body parts out of raw messages */
657 $length = 0; /* for fetching body parts out of raw messages */
658
659 function setEnt($ent)
660 {
661 $this->entity_id= $ent;
662 }
663
664 function addEntity ($msg)
665 {
666 $msg->parent = &$this;
667 $this->entities[] = $msg;
668 }
669
670 function addRFC822Header($read)
671 {
672 $header = new rfc822_header();
673 $this->rfc822_header = $header->parseHeader($read);
674 }
675
676 function getEntity($ent)
677 {
678 $cur_ent = $this->entity_id;
679 $msg = $this;
680 if ($cur_ent == '' || $cur_ent == '0')
681 {
682 $cur_ent_a = array();
683 } else
684 {
685 $cur_ent_a = explode('.',$this->entity_id);
686 }
687 $ent_a = explode('.',$ent);
688
689 $cnt = count($ent_a);
690
691 for ($i=0;$i<$cnt -1;$i++)
692 {
693 if (isset($cur_ent_a[$i]) && $cur_ent_a[$i] != $ent_a[$i])
694 {
695 $msg = $msg->parent;
696 $cur_ent_a = explode('.',$msg->entity_id);
697 $i--;
698 } else if (!isset($cur_ent_a[$i]))
699 {
700 if (isset($msg->entities[($ent_a[$i]-1)]))
701 {
702 $msg = $msg->entities[($ent_a[$i]-1)];
703 } else {
704 $msg = $msg->entities[0];
705 }
706 }
707 if ($msg->type0 == 'message' && $msg->type1 == 'rfc822')
708 {
709 /*this is a header for a message/rfc822 entity */
710 $msg = $msg->entities[0];
711 }
712 }
713
714 if ($msg->type0 == 'message' && $msg->type1 == 'rfc822')
715 {
716 /*this is a header for a message/rfc822 entity */
717 $msg = $msg->entities[0];
718 }
719
720 if (isset($msg->entities[($ent_a[$cnt-1])-1]))
721 {
722 $msg = $msg->entities[($ent_a[$cnt-1]-1)];
723 }
724
725 return $msg;
726 }
727
728 function setBody($s)
729 {
730 $this->body_part = $s;
731 }
732
733 function clean_up()
734 {
735 $msg = $this;
736 $msg->body_part = '';
737 $i=0;
738 while ( isset($msg->entities[$i]))
739 {
740 $msg->entities[$i]->clean_up();
741 $i++;
742 }
743 }
744
745 function getMailbox()
746 {
747 $msg = $this;
748 while (is_object($msg->parent))
749 {
750 $msg = $msg->parent;
751 }
752 return $msg->mailbox;
753 }
754
755 function calcEntity($msg)
756 {
757 if ($this->type0 == 'message' && $this->type1 == 'rfc822')
758 {
759 $msg->entity_id = $this->entity_id .'.0'; /* header of message/rfc822 */
760 } else if (isset($this->entity_id) && $this->entity_id !='')
761 {
762 $ent_no = count($this->entities)+1;
763 $par_ent = substr($this->entity_id,-2);
764 if ($par_ent{0} == '.')
765 {
766 $par_ent = $par_ent{1};
767 }
768 if ($par_ent == '0')
769 {
770 $ent_no = count($this->entities)+1;
771 if ($ent_no > 0)
772 {
773 $ent = substr($this->entity_id,0,strrpos($this->entity_id,'.'));
774 if ($ent)
775 {
776 $ent = $ent . ".$ent_no";
777 } else
778 {
779 $ent = $ent_no;
780 }
781 $msg->entity_id = $ent;
782 } else
783 {
784 $msg->entity_id = $ent_no;
785 }
786 } else
787 {
788 $ent = $this->entity_id . ".$ent_no";
789 $msg->entity_id = $ent;
790 }
791 } else
792 {
793 $msg->entity_id = '0';
794 }
795 return $msg->entity_id;
796 }
797
798
799 /*
800 * Bodystructure parser, a recursive function for generating the
801 * entity-tree with all the mime-parts.
802 *
803 * It follows RFC2060 and stores all the described fields in the
804 * message object.
805 *
806 * Question/Bugs:
807 *
808 * Ask for me (Marc Groot Koerkamp, stekkel@users.sourceforge.net.
809 *
810 */
811 function parseStructure($read, $i=0)
812 {
813 $arg_no = 0;
814 $arg_a = array();
815 $cnt = strlen($read);
816 while ($i < $cnt)
817 {
818 $char = strtoupper($read{$i});
819 switch ($char)
820 {
821 case '(':
822 if ($arg_no == 0 )
823 {
824 if (!isset($msg))
825 {
826 $msg = new message();
827 $hdr = new msg_header();
828 $hdr->type0 = 'text';
829 $hdr->type1 = 'plain';
830 $hdr->encoding = 'us-ascii';
831 $msg->entity_id = $this->calcEntity($msg);
832 } else
833 {
834 $msg->header->type0 = 'multipart';
835 $msg->type0 = 'multipart';
836 while ($read{$i} == '(')
837 {
838 $res = $msg->parseStructure($read,$i);
839 $i = $res[1];
840 $msg->addEntity($res[0]);
841 }
842 }
843 } else
844 {
845 switch ($arg_no)
846 {
847 case 1:
848 /* multipart properties */
849 $i++;
850 $res = $this->parseProperties($read,$i);
851
852 $arg_a[] = $res[0];
853 $i = $res[1];
854 $arg_no++;
855 break;
856 case 2:
857 if (isset($msg->type0) && $msg->type0 == 'multipart')
858 {
859 $i++;
860 $res = $msg->parseDisposition($read,$i);
861 $arg_a[] = $res[0];
862 $i = $res[1];
863 } else /* properties */
864 {
865 $res = $msg->parseProperties($read,$i);
866 $arg_a[] = $res[0];
867 $i = $res[1];
868 }
869 $arg_no++;
870 break;
871 case 3:
872 if (isset($msg->type0) && $msg->type0 == 'multipart')
873 {
874 $i++;
875 $res= $msg->parseLanguage($read,$i);
876 $arg_a[] = $res[0];
877 $i = $res[1];
878 }
879 case 7:
880 if ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822')
881 {
882 $msg->header->type0 = $arg_a[0];
883 $msg->type0 = $arg_a[0];
884 $msg->header->type1 = $arg_a[1];
885 $msg->type1 = $arg_a[1];
886 $rfc822_hdr = new rfc822_header();
887 $res = $msg->parseEnvelope($read,$i,$rfc822_hdr);
888 $i = $res[1];
889 $msg->rfc822_header = $res[0];
890 $i++;
891 while ($i < $cnt && $read{$i} != '(')
892 {
893 $i++;
894 }
895 $res = $msg->parseStructure($read,$i);
896 $i = $res[1];
897 $msg->addEntity($res[0]);
898 }
899 break;
900 case 8:
901 $i++;
902 $res = $msg->parseDisposition($read,$i);
903 $arg_a[] = $res[0];
904 $i = $res[1];
905 $arg_no++;
906 break;
907 case 9:
908 if ($arg_a[0] == 'text' ||
909 ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
910 {
911 $i++;
912 $res = $msg->parseDisposition($read,$i);
913 $arg_a[] = $res[0];
914 $i = $res[1];
915 } else
916 {
917 $i++;
918 $res = $msg->parseLanguage($read,$i);
919 $arg_a[] = $res[0];
920 $i = $res[1];
921 }
922 $arg_no++;
923 break;
924 case 10:
925 if ($arg_a[0] == 'text' ||
926 ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
927 {
928 $i++;
929 $res = $msg->parseLanguage($read,$i);
930 $arg_a[] = $res[0];
931 $i = $res[1];
932 } else
933 {
934 $i = $msg->parseParenthesis($read,$i);
935 $arg_a[] = ''; /* not yet desribed in rfc2060 */
936 }
937 $arg_no++;
938 break;
939 default:
940 /* unknown argument, skip this part */
941 $i = $msg->parseParenthesis($read,$i);
942 $arg_a[] = '';
943 $arg_no++;
944 break;
945 } /* switch */
946 }
947 break;
948 case '"':
949 /* inside an entity -> start processing */
950 $debug = substr($read,$i,20);
951 $res = $msg->parseQuote($read,$i);
952 $arg_s = $res[0];
953 $i = $res[1];
954 $arg_no++;
955 if ($arg_no < 3) $arg_s = strtolower($arg_s); /* type0 and type1 */
956 $arg_a[] = $arg_s;
957 break;
958 case 'n':
959 case 'N':
960 /* probably NIL argument */
961 if (strtoupper(substr($read,$i,4)) == 'NIL ' ||
962 strtoupper(substr($read,$i,4)) == 'NIL)')
963 {
964 $arg_a[] = '';
965 $arg_no++;
966 $i = $i+2;
967 }
968 break;
969 case '{':
970 /* process the literal value */
971 $res = $msg->parseLiteral($read,$i);
972 $arg_s = $res[0];
973 $i = $res[1];
974 $arg_no++;
975 break;
976 case (is_numeric($read{$i}) ):
977 /* process integers */
978 if ($read{$i} == ' ') break;
979 $arg_s = $read{$i};;
980 $i++;
981 while (preg_match('/^[0-9]{1}$/',$read{$i}))
982 {
983 $arg_s .= $read{$i};
984 $i++;
985 }
986 $arg_no++;
987 $arg_a[] = $arg_s;
988 break;
989 case ')':
990 if (isset($msg->type0) && $msg->type0 == 'multipart')
991 {
992 $multipart = true;
993 } else
994 {
995 $multipart = false;
996 }
997 if (!$multipart)
998 {
999 if ($arg_a[0] == 'text' ||
1000 ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
1001 {
1002 $shifted_args = true;
1003 } else
1004 {
1005 $shifted_args = false;
1006 }
1007 $hdr->type0 = $arg_a[0];
1008 $hdr->type1 = $arg_a[1];
1009
1010 $msg->type0 = $arg_a[0];
1011 $msg->type1 = $arg_a[1];
1012
1013 $arr = $arg_a[2];
1014 if (is_array($arr))
1015 {
1016 $hdr->parameters = $arg_a[2];
1017 }
1018 $hdr->id = str_replace( '<', '', str_replace( '>', '', $arg_a[3] ) );
1019 $hdr->description = $arg_a[4];
1020 $hdr->encoding = strtolower($arg_a[5]);
1021 $hdr->entity_id = $msg->entity_id;
1022 $hdr->size = $arg_a[6];
1023 if ($shifted_args)
1024 {
1025 $hdr->lines = $arg_a[7];
1026 if (isset($arg_a[8]))
1027 {
1028 $hdr->md5 = $arg_a[8];
1029 }
1030 if (isset($arg_a[9]))
1031 {
1032 $hdr->disposition = $arg_a[9];
1033 }
1034 if (isset($arg_a[10]))
1035 {
1036 $hdr->language = $arg_a[10];
1037 }
1038 } else
1039 {
1040 if (isset($arg_a[7]))
1041 {
1042 $hdr->md5 = $arg_a[7];
1043 }
1044 if (isset($arg_a[8]))
1045 {
1046 $hdr->disposition = $arg_a[8];
1047 }
1048 if (isset($arg_a[9]))
1049 {
1050 $hdr->language = $arg_a[9];
1051 }
1052 }
1053 $msg->header = $hdr;
1054 $arg_no = 0;
1055 $i++;
1056 if (substr($msg->entity_id,-2) == '.0' && $msg->type0 !='multipart')
1057 {
1058 $msg->entity_id++;
1059 }
1060 return (array($msg, $i));
1061 } else
1062 {
1063 $hdr->type0 = 'multipart';
1064 $hdr->type1 = $arg_a[0];
1065 $msg->type0 = 'multipart';
1066 $msg->type1 = $arg_a[0];
1067 if (is_array($arg_a[1]))
1068 {
1069 $hdr->parameters = $arg_a[1];
1070 }
1071 if (isset($arg_a[2]))
1072 {
1073 $hdr->disposition = $arg_a[2];
1074 }
1075 if (isset($arg_a[3]))
1076 {
1077 $hdr->language = $arg_a[3];
1078 }
1079 $msg->header = $hdr;
1080 return (array($msg, $i));
1081 }
1082 default:
1083 break;
1084 } /* switch */
1085 $i++;
1086 } /* while */
1087 } /* parsestructure */
1088
1089 function parseProperties($read, $i)
1090 {
1091 $properties = array();
1092 $arg_s = '';
1093 $prop_name = '';
1094 while ($read{$i} != ')')
1095 {
1096 if ($read{$i} == '"')
1097 {
1098 $res = $this->parseQuote($read,$i);
1099 $arg_s = $res[0];
1100 $i = $res[1];
1101 } else if ($read{$i} == '{')
1102 {
1103 $res = $this->parseLiteral($read,$i);
1104 $arg_s = $res[0];
1105 $i = $res[1];
1106 }
1107 if ($prop_name == '' && $arg_s)
1108 {
1109 $prop_name = strtolower($arg_s);
1110 $properties[$prop_name] = '';
1111 $arg_s = '';
1112 } elseif ($prop_name != '' && $arg_s != '')
1113 {
1114 $properties[$prop_name] = $arg_s;
1115 $prop_name = '';
1116 $arg_s = '';
1117 }
1118 $i++;
1119 }
1120 return (array($properties, $i));
1121 }
1122
1123 function parseEnvelope($read, $i, $hdr)
1124 {
1125 $arg_no = 0;
1126 $arg_a = array();
1127 $cnt = strlen($read);
1128 while ($i< $cnt && $read{$i} != ')')
1129 {
1130 $i++;
1131 $char = strtoupper($read{$i});
1132 switch ($char)
1133 {
1134 case '"':
1135 $res = $this->parseQuote($read,$i);
1136 $arg_a[] = $res[0];
1137 $i = $res[1];
1138 $arg_no++;
1139 break;
1140 case '{':
1141 $res = $this->parseLiteral($read,$i);
1142 $arg_a[] = $res[0];
1143 $i = $res[1];
1144 $arg_no++;
1145 break;
1146 case 'N':
1147 /* probably NIL argument */
1148 if (strtoupper(substr($read,$i,3)) == 'NIL') {
1149 $arg_a[] = '';
1150 $arg_no++;
1151 $i = $i+2;
1152 }
1153 break;
1154 case '(':
1155 /* Address structure
1156 * With group support.
1157 * Note: Group support is useless on SMTP connections
1158 * because the protocol doesn't support it
1159 */
1160 $addr_a = array();
1161 $group = '';
1162 $a=0;
1163 while ($i < $cnt && $read{$i} != ')')
1164 {
1165 if ($read{$i} == '(')
1166 {
1167 $res = $this->parseAddress($read,$i);
1168 $addr = $res[0];
1169 $i = $res[1];
1170 if ($addr->host == '' && $addr->mailbox != '')
1171 {
1172 /* start of group */
1173 $group = $addr->mailbox;
1174 $group_addr = $addr;
1175 $j = $a;
1176 } elseif ($group && $addr->host == '' && $addr->mailbox == '')
1177 {
1178 /* end group */
1179 if ($a == $j+1) /* no group members */
1180 {
1181 $group_addr->group = $group;
1182 $group_addr->mailbox = '';
1183 $group_addr->personal = "$group: Undisclosed recipients;";
1184 $addr_a[] = $group_addr;
1185 $group ='';
1186 }
1187 } else
1188 {
1189 $addr->group = $group;
1190 $addr_a[] = $addr;
1191 }
1192 $a++;
1193 }
1194 $i++;
1195 }
1196 $arg_a[] = $addr_a;
1197 break;
1198 default:
1199 break;
1200 }
1201 $i++;
1202 }
1203 if (count($arg_a) > 9)
1204 {
1205 /* argument 1: date */
1206 $d = strtr($arg_a[0], array(' ' => ' '));
1207 $d = explode(' ', $d);
1208 $hdr->date = getTimeStamp($d);
1209 /* argument 2: subject */
1210 if (!trim($arg_a[1]))
1211 {
1212 $arg_a[1]= _("(no subject)");
1213 }
1214 $hdr->subject = $arg_a[1];
1215 /* argument 3: from */
1216 $hdr->from = $arg_a[2][0];
1217 /* argument 4: sender */
1218 $hdr->sender = $arg_a[3][0];
1219 /* argument 5: reply-to */
1220 $hdr->replyto = $arg_a[4][0];
1221 /* argument 6: to */
1222 $hdr->to = $arg_a[5];
1223 /* argument 7: cc */
1224 $hdr->cc = $arg_a[6];
1225 /* argument 8: bcc */
1226 $hdr->bcc = $arg_a[7];
1227 /* argument 9: in-reply-to */
1228 $hdr->inreplyto = $arg_a[8];
1229 /* argument 10: message-id */
1230 $hdr->message_id = $arg_a[9];
1231 }
1232 return (array($hdr,$i));
1233 }
1234
1235 function parseLiteral($read, $i)
1236 {
1237 $lit_cnt = '';
1238 $i++;
1239 while ($read{$i} != '}')
1240 {
1241 $lit_cnt .= $read{$i};
1242 $i++;
1243 }
1244 $lit_cnt +=2; /* add the { and } characters */
1245 $s = '';
1246 for ($j = 0; $j < $lit_cnt; $j++)
1247 {
1248 $i++;
1249 $s .= $read{$i};
1250 }
1251 return (array($s, $i));
1252 }
1253
1254 function parseQuote($read, $i)
1255 {
1256 $i++;
1257 $s = '';
1258 while ($read{$i} != '"')
1259 {
1260 if ($read{$i} == '\\')
1261 {
1262 $i++;
1263 }
1264 $s .= $read{$i};
1265 $i++;
1266 }
1267 return (array($s, $i));
1268 }
1269
1270 function parseAddress($read, $i)
1271 {
1272 $arg_a = array();
1273 while ($read{$i} != ')' )
1274 {
1275 $char = strtoupper($read{$i});
1276 switch ($char)
1277 {
1278 case '"':
1279 $res = $this->parseQuote($read,$i);
1280 $arg_a[] = $res[0];
1281 $i = $res[1];
1282 break;
1283 case '{':
1284 $res = $this->parseLiteral($read,$i);
1285 $arg_a[] = $res[0];
1286 $i = $res[1];
1287 break;
1288 case 'n':
1289 case 'N':
1290 if (strtoupper(substr($read,$i,3)) == 'NIL') {
1291 $arg_a[] = '';
1292 $i = $i+2;
1293 }
1294 break;
1295 default:
1296 break;
1297 }
1298 $i++;
1299 }
1300 if (count($arg_a) == 4)
1301 {
1302 $adr = new address_structure();
1303 $adr->personal = $arg_a[0];
1304 $adr->adl = $arg_a[1];
1305 $adr->mailbox = $arg_a[2];
1306 $adr->host = $arg_a[3];
1307 } else
1308 {
1309 $adr = '';
1310 }
1311 return (array($adr,$i));
1312 }
1313
1314 function parseDisposition($read,$i)
1315 {
1316 $arg_a = array();
1317 while ($read{$i} != ')')
1318 {
1319 switch ($read{$i})
1320 {
1321 case '"':
1322 $res = $this->parseQuote($read,$i);
1323 $arg_a[] = $res[0];
1324 $i = $res[1];
1325 break;
1326 case '{':
1327 $res = $this->parseLiteral($read,$i);
1328 $arg_a[] = $res[0];
1329 $i = $res[1];
1330 break;
1331 case '(':
1332 $res = $this->parseProperties($read,$i);
1333 $arg_a[] = $res[0];
1334 $i = $res[1];
1335 break;
1336 default:
1337 break;
1338 }
1339 $i++;
1340 }
1341 if (isset($arg_a[0]))
1342 {
1343 $disp = new disposition($arg_a[0]);
1344 if (isset($arg_a[1]))
1345 {
1346 $disp->properties = $arg_a[1];
1347 }
1348 }
1349 if (is_object($disp))
1350 {
1351 return (array($disp, $i));
1352 } else
1353 {
1354 return (array('',$i));
1355 }
1356 }
1357
1358 function parseLanguage($read,$i)
1359 {
1360 /* no idea how to process this one without examples */
1361 $arg_a = array();
1362 while ($read{$i} != ')')
1363 {
1364 switch ($read{$i})
1365 {
1366 case '"':
1367 $res = $this->parseQuote($read,$i);
1368 $arg_a[] = $res[0];
1369 $i = $res[1];
1370 break;
1371 case '{':
1372 $res = $this->parseLiteral($read,$i);
1373 $arg_a[] = $res[0];
1374 $i = $res[1];
1375 break;
1376 case '(':
1377 $res = $this->parseProperties($read,$i);
1378 $arg_a[] = $res[0];
1379 $i = $res[1];
1380 break;
1381 default:
1382 break;
1383 }
1384 $i++;
1385 }
1386 if (isset($arg_a[0]))
1387 {
1388 $lang = new language($arg_a[0]);
1389 if (isset($arg_a[1]))
1390 {
1391 $lang->properties = $arg_a[1];
1392 }
1393 }
1394 if (is_object($lang))
1395 {
1396 return (array($lang, $i));
1397 } else
1398 {
1399 return (array('', $i));
1400 }
1401 }
1402
1403 function parseParenthesis($read,$i)
1404 {
1405 while ($read{$i} != ')')
1406 {
1407 switch ($read{$i})
1408 {
1409 case '"':
1410 $res = $this->parseQuote($read,$i);
1411 $i = $res[1];
1412 break;
1413 case '{':
1414 $res = $this->parseLiteral($read,$i);
1415 $i = $res[1];
1416 break;
1417 case '(':
1418 $res = $this->parseParenthesis($read,$i);
1419 $i = $res[1];
1420 break;
1421 default:
1422 break;
1423 }
1424 $i++;
1425 }
1426 return $i;
1427 }
1428
1429 /* function to fill the message structure in case the bodystructure
1430 isn't available NOT FINISHED YET
1431 */
1432 function parseMessage($read, $type0, $type1)
1433 {
1434 switch ($type0)
1435 {
1436 case 'message':
1437 $rfc822_header = true;
1438 $mime_header = false;
1439 break;
1440 case 'multipart':
1441 $mime_header = true;
1442 $rfc822_header = false;
1443 break;
1444 default:
1445 return $read;
1446 }
1447
1448 for ($i=1; $i < $count; $i++)
1449 {
1450 $line = trim($body[$i]);
1451 if ( ( $mime_header || $rfc822_header) &&
1452 (preg_match("/^.*boundary=\"?(.+(?=\")|.+).*/i",$line,$reg)) )
1453 {
1454 $bnd = $reg[1];
1455 $bndreg = $bnd;
1456 $bndreg = str_replace("\\","\\\\",$bndreg);
1457 $bndreg = str_replace("?","\\?",$bndreg);
1458 $bndreg = str_replace("+","\\+",$bndreg);
1459 $bndreg = str_replace(".","\\.",$bndreg);
1460 $bndreg = str_replace("/","\\/",$bndreg);
1461 $bndreg = str_replace("-","\\-",$bndreg);
1462 $bndreg = str_replace("(","\\(",$bndreg);
1463 $bndreg = str_replace(")","\\)",$bndreg);
1464 } elseif ( $rfc822_header && $line == '' )
1465 {
1466 $rfc822_header = false;
1467 if ($msg->type0 == 'multipart')
1468 {
1469 $mime_header = true;
1470 }
1471 }
1472
1473 if (($line{0} == '-' || $rfc822_header) && isset($boundaries[0]))
1474 {
1475 $cnt=count($boundaries)-1;
1476 $bnd = $boundaries[$cnt]['bnd'];
1477 $bndreg = $boundaries[$cnt]['bndreg'];
1478
1479 $regstr = '/^--'."($bndreg)".".*".'/';
1480 if (preg_match($regstr,$line,$reg) )
1481 {
1482 $bndlen = strlen($reg[1]);
1483 $bndend = false;
1484 if (strlen($line) > ($bndlen + 3))
1485 {
1486 if ($line{$bndlen+2} == '-' && $line{$bndlen+3} == '-')
1487 $bndend = true;
1488 }
1489 if ($bndend)
1490 {
1491 /* calc offset and return $msg */
1492 // $entStr = CalcEntity("$entStr",-1);
1493 array_pop($boundaries);
1494 $mime_header = true;
1495 $bnd_end = true;
1496 } else
1497 {
1498 $mime_header = true;
1499 $bnd_end = false;
1500 // $entStr = CalcEntity("$entStr",0);
1501 $content_indx++;
1502 }
1503 } else
1504 {
1505 if ($header)
1506 {
1507 }
1508 }
1509 }
1510 }
1511 }
1512
1513 function findDisplayEntity ($entity = array(), $alt_order = array('text/plain','text/html'))
1514 {
1515 $found = false;
1516 $type = $this->type0.'/'.$this->type1;
1517 if ( $type == 'multipart/alternative')
1518 {
1519 $msg = $this->findAlternativeEntity($alt_order);
1520 if (count($msg->entities) == 0)
1521 {
1522 $entity[] = $msg->entity_id;
1523 } else
1524 {
1525 $entity = $msg->findDisplayEntity($entity, $alt_order);
1526 }
1527 $found = true;
1528 } else if ( $type == 'multipart/related')
1529 {
1530 $msgs = $this->findRelatedEntity();
1531 foreach ($msgs as $msg)
1532 {
1533 if (count($msg->entities) == 0)
1534 {
1535 $entity[] = $msg->entity_id;
1536 } else
1537 {
1538 $entity = $msg->findDisplayEntity($entity,$alt_order);
1539 }
1540 }
1541 if (count($msgs) > 0) {
1542 $found = true;
1543 }
1544 } else if ($this->type0 == 'text' &&
1545 ($this->type1 == 'plain' ||
1546 $this->type1 == 'html' ||
1547 $this->type1 == 'message') &&
1548 isset($this->entity_id) )
1549 {
1550 if (count($this->entities) == 0)
1551 {
1552 if (strtolower($this->header->disposition->name) != 'attachment')
1553 {
1554 $entity[] = $this->entity_id;
1555 }
1556 }
1557 }
1558 $i = 0;
1559 if(!$found) {
1560 foreach ($this->entities as $ent) {
1561 if(strtolower($ent->header->disposition->name) != 'attachment' &&
1562 ($ent->type0 != 'message' && $ent->type1 != 'rfc822'))
1563 {
1564 $entity = $ent->findDisplayEntity($entity, $alt_order);
1565 }
1566 }
1567 }
1568 /*
1569 while ( isset($this->entities[$i]) && !$found &&
1570 (strtolower($this->entities[$i]->header->disposition->name)
1571 != 'attachment') &&
1572 ($this->entities[$i]->type0 != 'message' &&
1573 $this->entities[$i]->type1 != 'rfc822' )
1574 )
1575 {
1576 $entity = $this->entities[$i]->findDisplayEntity($entity, $alt_order);
1577 $i++;
1578 }
1579 */
1580 return( $entity );
1581 }
1582
1583 function findAlternativeEntity ($alt_order)
1584 {
1585 /* if we are dealing with alternative parts then we choose the best
1586 * viewable message supported by SM.
1587 */
1588 $best_view = 0;
1589 $entity = array();
1590 $altcount = count($alt_order);
1591 foreach($this->entities as $ent)
1592 {
1593 $type = $ent->header->type0.'/'.$ent->header->type1;
1594 if ($type == 'multipart/related')
1595 {
1596 $type = $ent->header->getParameter('type');
1597 }
1598 for ($j = $best_view; $j < $altcount; $j++)
1599 {
1600 if ($alt_order[$j] == $type && $j >= $best_view)
1601 {
1602 $best_view = $j;
1603 $entity = $ent;
1604 }
1605 }
1606 }
1607 return $entity;
1608 }
1609
1610 function findRelatedEntity ()
1611 {
1612 $msgs = array();
1613 $entcount = count($this->entities);
1614 for ($i = 0; $i < $entcount; $i++)
1615 {
1616 $type = $this->entities[$i]->header->type0.'/'.$this->entities[$i]->header->type1;
1617 if ($this->header->getParameter('type') == $type)
1618 {
1619 $msgs[] = $this->entities[$i];
1620 }
1621 }
1622 return $msgs;
1623 }
1624
1625 function getAttachments($exclude_id=array(), $result = array())
1626 {
1627 if ($this->type0 == 'message' && $this->type1 == 'rfc822')
1628 {
1629 $this = $this->entities[0];
1630 }
1631 if (count($this->entities))
1632 {
1633 foreach ($this->entities as $entity)
1634 {
1635 $exclude = false;
1636 foreach ($exclude_id as $excl)
1637 {
1638 if ($entity->entity_id === $excl)
1639 {
1640 $exclude = true;
1641 }
1642 }
1643 if (!$exclude)
1644 {
1645 if ($entity->type0 == 'multipart' &&
1646 $entity->type1 != 'related')
1647 {
1648 $result = $entity->getAttachments($exclude_id, $result);
1649 } else if ($entity->type0 != 'multipart')
1650 {
1651 $result[] = $entity;
1652 }
1653 }
1654 }
1655 } else
1656 {
1657 $exclude = false;
1658 foreach ($exclude_id as $excl)
1659 {
1660 if ($this->entity_id == $excl)
1661 {
1662 $exclude = true;
1663 }
1664 }
1665 if (!$exclude)
1666 {
1667 $result[] = $this;
1668 }
1669 }
1670 return $result;
1671 }
1672 }
1673
1674 class smime_message
1675 {
1676 }
1677
1678 class disposition
1679 {
1680 function disposition($name)
1681 {
1682 $this->name = $name;
1683 $this->properties = array();
1684 }
1685
1686 function getProperty($par)
1687 {
1688 $value = strtolower($par);
1689 if (isset($this->properties[$par]))
1690 {
1691 return $this->properties[$par];
1692 }
1693 return '';
1694 }
1695
1696 }
1697
1698 class language
1699 {
1700 function language($name)
1701 {
1702 $this->name = $name;
1703 $this->properties = array();
1704 }
1705 }
1706
1707 class content_type
1708 {
1709 var $type0='text',
1710 $type1='plain',
1711 $properties='';
1712 function content_type($type)
1713 {
1714 $pos = strpos($type,'/');
1715 if ($pos > 0)
1716 {
1717 $this->type0 = substr($type,0,$pos);
1718 $this->type1 = substr($type,$pos+1);
1719 } else
1720 {
1721 $this->type0 = $type;
1722 }
1723 $this->properties = array();
1724 }
1725 }
1726
1727 ?>