program/include/rcube_message.php

   1 <?php
   2
   3 /*
   4  +-----------------------------------------------------------------------+
   5  | program/include/rcube_message.php                                     |
   6  |                                                                       |
   7  | This file is part of the Roundcube Webmail client                     |
   8  | Copyright (C) 2008-2010, Roundcube Dev. - Switzerland                 |
   9  | Licensed under the GNU GPL                                            |
  10  |                                                                       |
  11  | PURPOSE:                                                              |
  12  |   Logical representation of a mail message with all its data          |
  13  |   and related functions                                               |
  14  +-----------------------------------------------------------------------+
  15  | Author: Thomas Bruederli <roundcube@gmail.com>                        |
  16  +-----------------------------------------------------------------------+
  17
  18  $Id: rcube_message.php 4643 2011-04-11 12:24:00Z alec $
  19
  20 */
  21
  22
  23 /**
  24  * Logical representation of a mail message with all its data
  25  * and related functions
  26  *
  27  * @package    Mail
  28  * @author     Thomas Bruederli <roundcube@gmail.com>
  29  */
  30 class rcube_message
  31 {
  32     /**
  33      * Instace of rcmail.
  34      *
  35      * @var rcmail
  36      */
  37     private $app;
  38
  39     /**
  40      * Instance of imap class
  41      *
  42      * @var rcube_imap
  43      */
  44     private $imap;
  45     private $opt = array();
  46     private $inline_parts = array();
  47     private $parse_alternative = false;
  48
  49     public $uid = null;
  50     public $headers;
  51     public $structure;
  52     public $parts = array();
  53     public $mime_parts = array();
  54     public $attachments = array();
  55     public $subject = '';
  56     public $sender = null;
  57     public $is_safe = false;
  58
  59
  60     /**
  61      * __construct
  62      *
  63      * Provide a uid, and parse message structure.
  64      *
  65      * @param string $uid The message UID.
  66      *
  67      * @uses rcmail::get_instance()
  68      * @uses rcube_imap::decode_mime_string()
  69      * @uses self::set_safe()
  70      *
  71      * @see self::$app, self::$imap, self::$opt, self::$structure
  72      */
  73     function __construct($uid)
  74     {
  75         $this->app = rcmail::get_instance();
  76         $this->imap = $this->app->imap;
  77         $this->imap->get_all_headers = true;
  78
  79         $this->uid = $uid;
  80         $this->headers = $this->imap->get_headers($uid, NULL, true, true);
  81
  82         if (!$this->headers)
  83             return;
  84
  85         $this->subject = rcube_imap::decode_mime_string(
  86             $this->headers->subject, $this->headers->charset);
  87         list(, $this->sender) = each($this->imap->decode_address_list($this->headers->from));
  88
  89         $this->set_safe((intval($_GET['_safe']) || $_SESSION['safe_messages'][$uid]));
  90         $this->opt = array(
  91             'safe' => $this->is_safe,
  92             'prefer_html' => $this->app->config->get('prefer_html'),
  93             'get_url' => rcmail_url('get', array(
  94                 '_mbox' => $this->imap->get_mailbox_name(), '_uid' => $uid))
  95         );
  96
  97         if ($this->structure = $this->imap->get_structure($uid, $this->headers->body_structure)) {
  98             $this->get_mime_numbers($this->structure);
  99             $this->parse_structure($this->structure);
 100         }
 101         else {
 102             $this->body = $this->imap->get_body($uid);
 103         }
 104
 105         // notify plugins and let them analyze this structured message object
 106         $this->app->plugins->exec_hook('message_load', array('object' => $this));
 107     }
 108
 109
 110     /**
 111      * Return a (decoded) message header
 112      *
 113      * @param string $name Header name
 114      * @param bool   $row  Don't mime-decode the value
 115      * @return string Header value
 116      */
 117     public function get_header($name, $raw = false)
 118     {
 119         if ($this->headers->$name)
 120             $value = $this->headers->$name;
 121         else if ($this->headers->others[$name])
 122             $value = $this->headers->others[$name];
 123
 124         return $raw ? $value : $this->imap->decode_header($value);
 125     }
 126
 127
 128     /**
 129      * Set is_safe var and session data
 130      *
 131      * @param bool $safe enable/disable
 132      */
 133     public function set_safe($safe = true)
 134     {
 135         $this->is_safe = $safe;
 136         $_SESSION['safe_messages'][$this->uid] = $this->is_safe;
 137     }
 138
 139
 140     /**
 141      * Compose a valid URL for getting a message part
 142      *
 143      * @param string $mime_id Part MIME-ID
 144      * @return string URL or false if part does not exist
 145      */
 146     public function get_part_url($mime_id)
 147     {
 148         if ($this->mime_parts[$mime_id])
 149             return $this->opt['get_url'] . '&_part=' . $mime_id;
 150         else
 151             return false;
 152     }
 153
 154
 155     /**
 156      * Get content of a specific part of this message
 157      *
 158      * @param string $mime_id Part MIME-ID
 159      * @param resource $fp File pointer to save the message part
 160      * @return string Part content
 161      */
 162     public function get_part_content($mime_id, $fp=NULL)
 163     {
 164         if ($part = $this->mime_parts[$mime_id]) {
 165             // stored in message structure (winmail/inline-uuencode)
 166             if ($part->encoding == 'stream') {
 167                 if ($fp) {
 168                     fwrite($fp, $part->body);
 169                 }
 170                 return $fp ? true : $part->body;
 171             }
 172             // get from IMAP
 173             return $this->imap->get_message_part($this->uid, $mime_id, $part, NULL, $fp);
 174         } else
 175             return null;
 176     }
 177
 178
 179     /**
 180      * Determine if the message contains a HTML part
 181      *
 182      * @return bool True if a HTML is available, False if not
 183      */
 184     function has_html_part()
 185     {
 186         // check all message parts
 187         foreach ($this->parts as $pid => $part) {
 188             $mimetype = strtolower($part->ctype_primary . '/' . $part->ctype_secondary);
 189             if ($mimetype == 'text/html')
 190                 return true;
 191         }
 192
 193         return false;
 194     }
 195
 196
 197     /**
 198      * Return the first HTML part of this message
 199      *
 200      * @return string HTML message part content
 201      */
 202     function first_html_part()
 203     {
 204         // check all message parts
 205         foreach ($this->mime_parts as $mime_id => $part) {
 206             $mimetype = strtolower($part->ctype_primary . '/' . $part->ctype_secondary);
 207             if ($mimetype == 'text/html') {
 208                 return $this->imap->get_message_part($this->uid, $mime_id, $part);
 209             }
 210         }
 211     }
 212
 213
 214     /**
 215      * Return the first text part of this message
 216      *
 217      * @param rcube_message_part $part Reference to the part if found
 218      * @return string Plain text message/part content
 219      */
 220     function first_text_part(&$part=null)
 221     {
 222         // no message structure, return complete body
 223         if (empty($this->parts))
 224             return $this->body;
 225
 226         // check all message parts
 227         foreach ($this->mime_parts as $mime_id => $part) {
 228             $mimetype = $part->ctype_primary . '/' . $part->ctype_secondary;
 229
 230             if ($mimetype == 'text/plain') {
 231                 return $this->imap->get_message_part($this->uid, $mime_id, $part);
 232             }
 233             else if ($mimetype == 'text/html') {
 234                 $out = $this->imap->get_message_part($this->uid, $mime_id, $part);
 235
 236                 // remove special chars encoding
 237                 $trans = array_flip(get_html_translation_table(HTML_ENTITIES));
 238                 $out = strtr($out, $trans);
 239
 240                 // create instance of html2text class
 241                 $txt = new html2text($out);
 242                 return $txt->get_text();
 243             }
 244         }
 245
 246         $part = null;
 247         return null;
 248     }
 249
 250
 251     /**
 252      * Raad the message structure returend by the IMAP server
 253      * and build flat lists of content parts and attachments
 254      *
 255      * @param rcube_message_part $structure Message structure node
 256      * @param bool               $recursive True when called recursively
 257      */
 258     private function parse_structure($structure, $recursive = false)
 259     {
 260         // real content-type of message/rfc822 part
 261         if ($structure->mimetype == 'message/rfc822' && $structure->real_mimetype)
 262             $mimetype = $structure->real_mimetype;
 263         else
 264             $mimetype = $structure->mimetype;
 265
 266         // show message headers
 267         if ($recursive && is_array($structure->headers) && isset($structure->headers['subject'])) {
 268             $c = new stdClass;
 269             $c->type = 'headers';
 270             $c->headers = &$structure->headers;
 271             $this->parts[] = $c;
 272         }
 273
 274         // Allow plugins to handle message parts
 275         $plugin = $this->app->plugins->exec_hook('message_part_structure',
 276             array('object' => $this, 'structure' => $structure,
 277                 'mimetype' => $mimetype, 'recursive' => $recursive));
 278
 279         if ($plugin['abort'])
 280             return;
 281
 282         $structure = $plugin['structure'];
 283         list($message_ctype_primary, $message_ctype_secondary) = explode('/', $plugin['mimetype']);
 284
 285         // print body if message doesn't have multiple parts
 286         if ($message_ctype_primary == 'text' && !$recursive) {
 287             $structure->type = 'content';
 288             $this->parts[] = &$structure;
 289
 290             // Parse simple (plain text) message body
 291             if ($message_ctype_secondary == 'plain')
 292                 foreach ((array)$this->uu_decode($structure) as $uupart) {
 293                     $this->mime_parts[$uupart->mime_id] = $uupart;
 294                     $this->attachments[] = $uupart;
 295                 }
 296         }
 297         // the same for pgp signed messages
 298         else if ($mimetype == 'application/pgp' && !$recursive) {
 299             $structure->type = 'content';
 300             $this->parts[] = &$structure;
 301         }
 302         // message contains alternative parts
 303         else if ($mimetype == 'multipart/alternative' && is_array($structure->parts)) {
 304             // get html/plaintext parts
 305             $plain_part = $html_part = $print_part = $related_part = null;
 306
 307             foreach ($structure->parts as $p => $sub_part) {
 308                 $sub_mimetype = $sub_part->mimetype;
 309
 310                 // check if sub part is
 311                 if ($sub_mimetype == 'text/plain')
 312                     $plain_part = $p;
 313                 else if ($sub_mimetype == 'text/html')
 314                     $html_part = $p;
 315                 else if ($sub_mimetype == 'text/enriched')
 316                     $enriched_part = $p;
 317                 else if (in_array($sub_mimetype, array('multipart/related', 'multipart/mixed', 'multipart/alternative')))
 318                     $related_part = $p;
 319             }
 320
 321             // parse related part (alternative part could be in here)
 322             if ($related_part !== null && !$this->parse_alternative) {
 323                 $this->parse_alternative = true;
 324                 $this->parse_structure($structure->parts[$related_part], true);
 325                 $this->parse_alternative = false;
 326
 327                 // if plain part was found, we should unset it if html is preferred
 328                 if ($this->opt['prefer_html'] && count($this->parts))
 329                     $plain_part = null;
 330             }
 331
 332             // choose html/plain part to print
 333             if ($html_part !== null && $this->opt['prefer_html']) {
 334                 $print_part = &$structure->parts[$html_part];
 335             }
 336             else if ($enriched_part !== null) {
 337                 $print_part = &$structure->parts[$enriched_part];
 338             }
 339             else if ($plain_part !== null) {
 340                 $print_part = &$structure->parts[$plain_part];
 341             }
 342
 343             // add the right message body
 344             if (is_object($print_part)) {
 345                 $print_part->type = 'content';
 346                 $this->parts[] = $print_part;
 347             }
 348             // show plaintext warning
 349             else if ($html_part !== null && empty($this->parts)) {
 350                 $c = new stdClass;
 351                 $c->type            = 'content';
 352                 $c->ctype_primary   = 'text';
 353                 $c->ctype_secondary = 'plain';
 354                 $c->body            = rcube_label('htmlmessage');
 355
 356                 $this->parts[] = $c;
 357             }
 358
 359             // add html part as attachment
 360             if ($html_part !== null && $structure->parts[$html_part] !== $print_part) {
 361                 $html_part = &$structure->parts[$html_part];
 362                 $html_part->filename = rcube_label('htmlmessage');
 363                 $html_part->mimetype = 'text/html';
 364
 365                 $this->attachments[] = $html_part;
 366             }
 367         }
 368         // this is an ecrypted message -> create a plaintext body with the according message
 369         else if ($mimetype == 'multipart/encrypted') {
 370             $p = new stdClass;
 371             $p->type            = 'content';
 372             $p->ctype_primary   = 'text';
 373             $p->ctype_secondary = 'plain';
 374             $p->body            = rcube_label('encryptedmessage');
 375             $p->size            = strlen($p->body);
 376         }
 377         // message contains multiple parts
 378         else if (is_array($structure->parts) && !empty($structure->parts)) {
 379             // iterate over parts
 380             for ($i=0; $i < count($structure->parts); $i++) {
 381                 $mail_part      = &$structure->parts[$i];
 382                 $primary_type   = $mail_part->ctype_primary;
 383                 $secondary_type = $mail_part->ctype_secondary;
 384
 385                 // real content-type of message/rfc822
 386                 if ($mail_part->real_mimetype) {
 387                     $part_orig_mimetype = $mail_part->mimetype;
 388                     $part_mimetype = $mail_part->real_mimetype;
 389                     list($primary_type, $secondary_type) = explode('/', $part_mimetype);
 390                 }
 391                 else
 392                     $part_mimetype = $mail_part->mimetype;
 393
 394                 // multipart/alternative
 395                 if ($primary_type == 'multipart') {
 396                     $this->parse_structure($mail_part, true);
 397
 398                     // list message/rfc822 as attachment as well (mostly .eml)
 399                     if ($part_orig_mimetype == 'message/rfc822' && !empty($mail_part->filename))
 400                         $this->attachments[] = $mail_part;
 401                 }
 402                 // part text/[plain|html] or delivery status
 403                 else if ((($part_mimetype == 'text/plain' || $part_mimetype == 'text/html') && $mail_part->disposition != 'attachment') ||
 404                     in_array($part_mimetype, array('message/delivery-status', 'text/rfc822-headers', 'message/disposition-notification'))
 405                 ) {
 406                     // Allow plugins to handle also this part
 407                     $plugin = $this->app->plugins->exec_hook('message_part_structure',
 408                         array('object' => $this, 'structure' => $mail_part,
 409                             'mimetype' => $part_mimetype, 'recursive' => true));
 410
 411                     if ($plugin['abort'])
 412                         continue;
 413
 414                     if ($part_mimetype == 'text/html') {
 415                         $got_html_part = true;
 416                     }
 417
 418                     $mail_part = $plugin['structure'];
 419                     list($primary_type, $secondary_type) = explode('/', $plugin['mimetype']);
 420
 421                     // add text part if it matches the prefs
 422                     if (!$this->parse_alternative ||
 423                         ($secondary_type == 'html' && $this->opt['prefer_html']) ||
 424                         ($secondary_type == 'plain' && !$this->opt['prefer_html'])
 425                     ) {
 426                         $mail_part->type = 'content';
 427                         $this->parts[] = $mail_part;
 428                     }
 429
 430                     // list as attachment as well
 431                     if (!empty($mail_part->filename))
 432                         $this->attachments[] = $mail_part;
 433                 }
 434                 // part message/*
 435                 else if ($primary_type=='message') {
 436                     $this->parse_structure($mail_part, true);
 437
 438                     // list as attachment as well (mostly .eml)
 439                     if (!empty($mail_part->filename))
 440                         $this->attachments[] = $mail_part;
 441                 }
 442                 // ignore "virtual" protocol parts
 443                 else if ($primary_type == 'protocol') {
 444                     continue;
 445                 }
 446                 // part is Microsoft Outlook TNEF (winmail.dat)
 447                 else if ($part_mimetype == 'application/ms-tnef') {
 448                     foreach ((array)$this->tnef_decode($mail_part) as $tpart) {
 449                         $this->mime_parts[$tpart->mime_id] = $tpart;
 450                         $this->attachments[] = $tpart;
 451                     }
 452                 }
 453                 // part is a file/attachment
 454                 else if (preg_match('/^(inline|attach)/', $mail_part->disposition) ||
 455                     $mail_part->headers['content-id'] ||
 456                     ($mail_part->filename &&
 457                         (empty($mail_part->disposition) || preg_match('/^[a-z0-9!#$&.+^_-]+$/i', $mail_part->disposition)))
 458                 ) {
 459                     // skip apple resource forks
 460                     if ($message_ctype_secondary == 'appledouble' && $secondary_type == 'applefile')
 461                         continue;
 462
 463                     // part belongs to a related message and is linked
 464                     if ($mimetype == 'multipart/related'
 465                         && ($mail_part->headers['content-id'] || $mail_part->headers['content-location'])) {
 466                         if ($mail_part->headers['content-id'])
 467                             $mail_part->content_id = preg_replace(array('/^</', '/>$/'), '', $mail_part->headers['content-id']);
 468                         if ($mail_part->headers['content-location'])
 469                             $mail_part->content_location = $mail_part->headers['content-base'] . $mail_part->headers['content-location'];
 470
 471                         $this->inline_parts[] = $mail_part;
 472                     }
 473                     // attachment encapsulated within message/rfc822 part needs further decoding (#1486743)
 474                     else if ($part_orig_mimetype == 'message/rfc822') {
 475                         $this->parse_structure($mail_part, true);
 476
 477                         // list as attachment as well (mostly .eml)
 478                         if (!empty($mail_part->filename))
 479                             $this->attachments[] = $mail_part;
 480                     }
 481                     // regular attachment with valid content type
 482                     // (content-type name regexp according to RFC4288.4.2)
 483                     else if (preg_match('/^[a-z0-9!#$&.+^_-]+\/[a-z0-9!#$&.+^_-]+$/i', $part_mimetype)) {
 484                         if (!$mail_part->filename)
 485                             $mail_part->filename = 'Part '.$mail_part->mime_id;
 486
 487                         $this->attachments[] = $mail_part;
 488                     }
 489                     // attachment with invalid content type
 490                     // replace malformed content type with application/octet-stream (#1487767)
 491                     else if ($mail_part->filename) {
 492                         $mail_part->ctype_primary   = 'application';
 493                         $mail_part->ctype_secondary = 'octet-stream';
 494                         $mail_part->mimetype        = 'application/octet-stream';
 495
 496                         $this->attachments[] = $mail_part;
 497                     }
 498                 }
 499             }
 500
 501             // if this was a related part try to resolve references
 502             if ($mimetype == 'multipart/related' && sizeof($this->inline_parts)) {
 503                 $a_replaces = array();
 504
 505                 foreach ($this->inline_parts as $inline_object) {
 506                     $part_url = $this->get_part_url($inline_object->mime_id);
 507                     if ($inline_object->content_id)
 508                         $a_replaces['cid:'.$inline_object->content_id] = $part_url;
 509                     if ($inline_object->content_location) {
 510                         $a_replaces[$inline_object->content_location] = $part_url;
 511                     }
 512                     // MS Outlook sends sometimes non-related attachments as related
 513                     // In this case multipart/related message has only one text part
 514                     // We'll add all such attachments to the attachments list
 515                     if (!isset($got_html_part) && empty($inline_object->content_id)
 516                         && !empty($inline_object->filename)
 517                     ) {
 518                         $this->attachments[] = $inline_object;
 519                     }
 520                     // MS Outlook sometimes also adds non-image attachments as related
 521                     // We'll add all such attachments to the attachments list
 522                     // Warning: some browsers support pdf in <img/>
 523                     // @TODO: we should fetch HTML body and find attachment's content-id
 524                     // to handle also image attachments without reference in the body
 525                     if (!empty($inline_object->filename)
 526                         && !preg_match('/^image\/(gif|jpe?g|png|tiff|bmp|svg)/', $inline_object->mimetype)
 527                     ) {
 528                         $this->attachments[] = $inline_object;
 529                     }
 530                 }
 531
 532                 // add replace array to each content part
 533                 // (will be applied later when part body is available)
 534                 foreach ($this->parts as $i => $part) {
 535                     if ($part->type == 'content')
 536                         $this->parts[$i]->replaces = $a_replaces;
 537                 }
 538             }
 539         }
 540         // message is a single part non-text
 541         else if ($structure->filename) {
 542             $this->attachments[] = $structure;
 543         }
 544         // message is a single part non-text (without filename)
 545         else if (preg_match('/application\//i', $mimetype)) {
 546             $structure->filename = 'Part '.$structure->mime_id;
 547             $this->attachments[] = $structure;
 548         }
 549     }
 550
 551
 552     /**
 553      * Fill aflat array with references to all parts, indexed by part numbers
 554      *
 555      * @param rcube_message_part $part Message body structure
 556      */
 557     private function get_mime_numbers(&$part)
 558     {
 559         if (strlen($part->mime_id))
 560             $this->mime_parts[$part->mime_id] = &$part;
 561
 562         if (is_array($part->parts))
 563             for ($i=0; $i<count($part->parts); $i++)
 564                 $this->get_mime_numbers($part->parts[$i]);
 565     }
 566
 567
 568     /**
 569      * Decode a Microsoft Outlook TNEF part (winmail.dat)
 570      *
 571      * @param rcube_message_part $part Message part to decode
 572      * @return array
 573      */
 574     function tnef_decode(&$part)
 575     {
 576         // @TODO: attachment may be huge, hadle it via file
 577         if (!isset($part->body))
 578             $part->body = $this->imap->get_message_part($this->uid, $part->mime_id, $part);
 579
 580         $parts = array();
 581         $tnef = new tnef_decoder;
 582         $tnef_arr = $tnef->decompress($part->body);
 583
 584         foreach ($tnef_arr as $pid => $winatt) {
 585             $tpart = new rcube_message_part;
 586
 587             $tpart->filename        = trim($winatt['name']);
 588             $tpart->encoding        = 'stream';
 589             $tpart->ctype_primary   = trim(strtolower($winatt['type']));
 590             $tpart->ctype_secondary = trim(strtolower($winatt['subtype']));
 591             $tpart->mimetype        = $tpart->ctype_primary . '/' . $tpart->ctype_secondary;
 592             $tpart->mime_id         = 'winmail.' . $part->mime_id . '.' . $pid;
 593             $tpart->size            = $winatt['size'];
 594             $tpart->body            = $winatt['stream'];
 595
 596             $parts[] = $tpart;
 597             unset($tnef_arr[$pid]);
 598         }
 599
 600         return $parts;
 601     }
 602
 603
 604     /**
 605      * Parse message body for UUencoded attachments bodies
 606      *
 607      * @param rcube_message_part $part Message part to decode
 608      * @return array
 609      */
 610     function uu_decode(&$part)
 611     {
 612         // @TODO: messages may be huge, hadle body via file
 613         if (!isset($part->body))
 614             $part->body = $this->imap->get_message_part($this->uid, $part->mime_id, $part);
 615
 616         $parts = array();
 617         // FIXME: line length is max.65?
 618         $uu_regexp = '/begin [0-7]{3,4} ([^\n]+)\n(([\x21-\x7E]{0,65}\n)+)`\nend/s';
 619
 620         if (preg_match_all($uu_regexp, $part->body, $matches, PREG_SET_ORDER)) {
 621             // remove attachments bodies from the message body
 622             $part->body = preg_replace($uu_regexp, '', $part->body);
 623             // update message content-type
 624             $part->ctype_primary   = 'multipart';
 625             $part->ctype_secondary = 'mixed';
 626             $part->mimetype        = $part->ctype_primary . '/' . $part->ctype_secondary;
 627
 628             // add attachments to the structure
 629             foreach ($matches as $pid => $att) {
 630                 $uupart = new rcube_message_part;
 631
 632                 $uupart->filename = trim($att[1]);
 633                 $uupart->encoding = 'stream';
 634                 $uupart->body     = convert_uudecode($att[2]);
 635                 $uupart->size     = strlen($uupart->body);
 636                 $uupart->mime_id  = 'uu.' . $part->mime_id . '.' . $pid;
 637
 638                 $ctype = rc_mime_content_type($uupart->body, $uupart->filename, 'application/octet-stream', true);
 639                 $uupart->mimetype = $ctype;
 640                 list($uupart->ctype_primary, $uupart->ctype_secondary) = explode('/', $ctype);
 641
 642                 $parts[] = $uupart;
 643                 unset($matches[$pid]);
 644             }
 645         }
 646
 647         return $parts;
 648     }
 649
 650
 651     /**
 652      * Interpret a format=flowed message body according to RFC 2646
 653      *
 654      * @param string  $text Raw body formatted as flowed text
 655      * @return string Interpreted text with unwrapped lines and stuffed space removed
 656      */
 657     public static function unfold_flowed($text)
 658     {
 659         $text = preg_split('/\r?\n/', $text);
 660         $last = -1;
 661         $q_level = 0;
 662
 663         foreach ($text as $idx => $line) {
 664             if ($line[0] == '>' && preg_match('/^(>+\s*)/', $line, $regs)) {
 665                 $q = strlen(str_replace(' ', '', $regs[0]));
 666                 $line = substr($line, strlen($regs[0]));
 667
 668                 if ($q == $q_level && $line
 669                     && isset($text[$last])
 670                     && $text[$last][strlen($text[$last])-1] == ' '
 671                 ) {
 672                     $text[$last] .= $line;
 673                     unset($text[$idx]);
 674                 }
 675                 else {
 676                     $last = $idx;
 677                 }
 678             }
 679             else {
 680                 $q = 0;
 681                 if ($line == '-- ') {
 682                     $last = $idx;
 683                 }
 684                 else {
 685                     // remove space-stuffing
 686                     $line = preg_replace('/^\s/', '', $line);
 687
 688                     if (isset($text[$last]) && $line
 689                         && $text[$last] != '-- '
 690                         && $text[$last][strlen($text[$last])-1] == ' '
 691                     ) {
 692                         $text[$last] .= $line;
 693                         unset($text[$idx]);
 694                     }
 695                     else {
 696                         $text[$idx] = $line;
 697                         $last = $idx;
 698                     }
 699                 }
 700             }
 701             $q_level = $q;
 702         }
 703
 704         return implode("\r\n", $text);
 705     }
 706
 707
 708     /**
 709      * Wrap the given text to comply with RFC 2646
 710      *
 711      * @param string $text Text to wrap
 712      * @param int $length Length
 713      * @return string Wrapped text
 714      */
 715     public static function format_flowed($text, $length = 72)
 716     {
 717         $text = preg_split('/\r?\n/', $text);
 718
 719         foreach ($text as $idx => $line) {
 720             if ($line != '-- ') {
 721                 if ($line[0] == '>' && preg_match('/^(>+)/', $line, $regs)) {
 722                     $prefix = $regs[0];
 723                     $level = strlen($prefix);
 724                     $line  = rtrim(substr($line, $level));
 725                     $line  = $prefix . rc_wordwrap($line, $length - $level - 2, " \r\n$prefix ");
 726                 }
 727                 else if ($line) {
 728                     $line = rc_wordwrap(rtrim($line), $length - 2, " \r\n");
 729                     // space-stuffing
 730                     $line = preg_replace('/(^|\r\n)(From| |>)/', '\\1 \\2', $line);
 731                 }
 732
 733                 $text[$idx] = $line;
 734             }
 735         }
 736
 737         return implode("\r\n", $text);
 738     }
 739
 740 }