MailinglistMessage.class.php

Go to the documentation of this file.

<?php
  function mailinglist_message_rfc2047($string) {

    if (is_array($string)) {
      $result = array();
      foreach ($string as $idx => $value) {
        $result[$idx] = mailinglist_message_rfc2047($value);
      }
    }
    else {
    // RFC 2047 Processing
    // Look for tokens like: =?charset?encoding?text?=
    //
      $result = "";
      while ($string) {
        $pos = strpos($string, '=?');
        if ($pos === FALSE) {
          $result .= $string;
          $string = "";
          break;
        }
        if ($pos > 0) {
          $result .= substr($string, 0, $pos);
          $string = substr($string, $pos);
        }
        $pos0 = strpos($string, '?=');
        if ($pos0 === FALSE) { // no end, so no more encoded-words
          $result .= $string;
          $string = "";
          break;
        }
        $pos1 = strpos($string, ' ');
        if ($pos1 !== FALSE AND $pos1 < $pos0) {
          $result .= substr($string, 0, 2);
          $string = substr($string, 2);
          continue;
        }
        $pos1 = strpos($string, "\t");
        if ($pos1 !== FALSE AND $pos1 < $pos0) {
          $result .= substr($string, 0, 2);
          $string = substr($string, 2);
          continue;
        }
        $pos1 = strpos($string, '?', 2);
        if ($pos1 >= $pos0) {
          // not enough ? in between
          $result .= substr($string, 0, 2);
          $string = substr($string, 2);
          continue;
        }
        $charset = substr($string, 2, $pos1-2);
        $pos2 = strpos($string, '?', $pos1+1);
        if ($pos2 >= $pos0) {
          // not enough ? in between
          $result .= substr($string, 0, 2);
          $string = substr($string, 2);
          continue;
        }
        $encoding = substr($string, $pos1+1, $pos2 - $pos1 - 1);
        $text = substr($string, $pos2+1, $pos0 - $pos2 -1);
        $string = substr($string, $pos0+2);
        switch (strtolower($encoding)) {
        case 'b':
          $text = base64_decode($text);
          break;
        case 'q':
          $text = quoted_printable_decode($text);
          break;
        default:
          // We don't know what to do, so just pass it on.
          $text = '=?' . $charset . '?' . $encoding . '?=';
          break;
        }
        $text = iconv($charset, 'UTF-8', $text);
        $result .= $text;
      }
    }
    return $result;
  }


class MailinglistHeader{
  private $header;    

  function __construct($str) {
    $this->header = $str;
  }

  function get_atom() {
    static $atext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'*+-/=?^_`{}|~";
    $this->skip_ws();
    $str = $this->get_chunk($atext);
    $str = mailinglist_message_rfc2047($str);
    return $str;
  }

  function get_dot_atom() {
    $atom = $this->get_atom();
    while ($this->header[0] == '.') {
      $atom += $this->get_char();
      $atom += $this->get_atom();
    }
    return $atom;
  }

  function get_token() {
    static $ttext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'*+-^_`{}|~.";
    $this->skip_ws();
    return $this->get_chunk($ttext);
  }
  function get_value() {
    $this->skip_ws();
    if ($this->header[0] == '"') {
      $token = "";
      $this->get_char();
      while (($char = $this->get_char()) != '"' && $char !== FALSE) {
        if ($char == '\\') {
          $char = $this->get_char();
        }
        $token .= $char;
      }
      return $token;
    }
    else{
      return $this->get_token();
    }
  }

  private function get_chunk($chars) {
    $token = "";
    while (!empty($this->header) && strpos($chars, $this->header[0]) !== FALSE) {
      $token .= $this->get_char();
    }
    return $token;
  }
  function skip_ws() {
    while (ctype_space($this->header[0])) {
      $this->header = substr($this->header, 1);
    }
  }

  function skip_cws() {
    while (ctype_space($char = $this->header[0]) || $char == '(') {
      $this->get_char();
      if ($char == '(') {
        $this->skip_comment();
      }
    }
  }

  function skip_comment() {
    while (($char = $this->get_char()) != ')') {
      if ($char == '\\') {
        $this->get_char();  // Quoted char, so ignore the next
      }
      elseif ($char == '(') {
        $this->skip_comment();  // Nested comment
      }
    }
  }

  function get_char() {
    if (!empty($this->header)) {
      $char = $this->header[0];
      $this->header = substr($this->header, 1);
      return $char;
    }
    else {
      return FALSE;
    }
  }
  function push_back($char) {
    $this->header = $char . $this->header;
  }
}

class MailinglistMessagePart {
  public $headers;

  public $body;

  function headerRaw($name) {
    if (isset($this->headers[$name])) {
      return $this->headers[$name];
    }
    else return FALSE;
  }

  function header($name) {
    $header = $this->headerRaw($name);
    $header = mailinglist_message_rfc2047($header);

    return $header;
  }

  function headerEmail($name) {
    $name = $this->headerRaw($name);
    if (is_array($name)) {
      $result = array();
      foreach ($name as $key => $data) {
        $result[$key] = parseEmailAddr($data);
      }
    }
    else {
      $result = $this->parseEmailAddr($name);
    }

    return $result;
  }

  function headerNoComments($name) {
    $header = $this->header($name);
    if (is_array($header)) {
      foreach($header as $key => $data) {
        $result[$key] = $this->stripComments($data);
      }
    }
    else {
      $result = $this->stripComments($header);
    }
    return $result;
  }

  function addHeader($header_name, $header_value) {
    if (is_array($header_value)) {
      // if given an array, add each element
      foreach ($header_value as $value) {
        $this->addHeader($header_name, $value);
      }
    }
    else {
      $header_value = trim($header_value);
    // duplicate headers become arrays
      if (isset($this->headers[$header_name])) {
        if (!is_array($this->headers[$header_name])) {
          $this->headers[$header_name] = array($this->headers[$header_name]);
        }
        $this->headers[$header_name][] = $header_value;
      }
      else {
        $this->headers[$header_name] = $header_value;
      }
    }
  }

  function setHeader($header_name, $header_value) {
    $this->headers[$header_name] = $header_value;
  }

  function body() {
    return $this->body;
  }

  function headers() {
    return $this->headers;
  }

  function __construct($msg = NULL) {
    if (is_string($msg)) {
      $break = strpos($msg, "\n\n");
      $this->headers = substr($msg, 0, $break+1);
      $this->body = substr($msg, $break+2);

      $this->parseHeaders();
      $this->parseBody();
    }
  }

  function parseHeaders() {
    // Fix any character problems. If real email message, should only be ascii,
    // but some mbox files will have been converted, see if UTF or ISO-8859

    $charset = "";
    @$headers = iconv('UTF-8//IGNORE', 'UTF-8', $this->headers);
    if ($headers != $this->headers) {
      $headers = iconv('ISO-8859-1//IGNORE', 'UTF-8', $this->headers);
      $charset = 'ISO-8859-1';
    }

    // Unfold headers newline-whitespace => space
    $headers = preg_replace('/\n\s+/', ' ', $headers);
    // Convert to an array of headers
    $headers = explode("\n", $headers);
    // Build up the associative array of the headers
    $this->headers = array();
    if(!empty($charset)){
      $this->addHeader('XX-HeaderCharset', $charset);
    }
    foreach ($headers as $header) {
      $colon = strpos($header, ': ');
      if ($colon > 0) {
        $header_name = substr($header, 0, $colon);
        $header_value = substr($header, $colon+2);

        switch ($header_name) {
          case 'References':
            $header_value = str_replace("\t", " ", $header_value);
            $header_value = str_replace('><', '> <', $header_value);
            $header_value = explode(' ', $header_value);
            break;
          case 'To':
          case 'Cc':
          case 'From':
          case 'Reply-To':
            $pos = 0;
            // See if there is a comma to process, start at beginning
            while( FALSE !== ($posc = strpos($header_value, ',', $pos))){
              $pos1 = strpos($header_value, '(', $pos);
              $pos2 = strpos($header_value, '<', $pos);
              $pos3 = strpos($header_value, '\\', $pos);
              $pos4 = strpos($header_value, '"', $pos);
              if($pos1 === FALSE) $pos1 = $posc;
              if($pos2 === FALSE) $pos2 = $posc;
              if($pos3 === FALSE) $pos3 = $posc;
              if($pos4 === FALSE) $pos4 = $posc;
              $pos1 = min($pos1, $pos2, $pos3, $pos4);
              if($pos1 < $posc) {
                switch($header_value[$pos1]) {
                  case '(':
                    $pos = strpos($header_value, ')', $pos1);
                    if(!$pos) $pos = $pos1+1;
                    break;
                  case '<':
                    $pos = strpos($header_value, '>', $pos1);
                    if(!$pos) $pos = $pos1+1;
                    break;
                  case '\\':
                    $pos = $pos1+2;
                    break;
                  case '"':
                    $pos = strpos($header_value, '"', $pos1+1);
                    if(!$pos) $pos = $pos1+1;
                    break;
                  default:
                    $this->logError('Error Processing Header: ' . $header_value);
                    break;
                }
              }
              else {
                // All quotes are after the comma, so process it.
                $value = substr($header_value, 0, $posc);
                $this->addHeader($header_name, $value);
                // Strip out value, and process after the ,
                $header_value = substr($header_value, $posc+1);
                $pos = 0;
              }
            }
          default:
            break;
        }
        $this->addHeader($header_name, $header_value);
      }
    }
  }

  function parseBody() {

    if (isset($this->headers['Content-Transfer-Encoding'])) {
      $header = new MailinglistHeader($this->headers['Content-Transfer-Encoding']);
      $cte = $header->get_atom();

      switch (strtolower($cte)) {
        case 'quoted-printable':
          $this->body = quoted_printable_decode($this->body);
          break;
        case 'base64':
          $this->body = base64_decode($this->body);
          break;
        default:
          $this->logError('Unknown CTE "@cte"', array('@cte' => $cte));
        case 'binary':
        case '8bit':
        case '7bit':
          // These encodings use a null transform, so we can ignore them
          break;
      }
    }
    else {
      $cte = '7bit';
    }

    if (isset($this->headers['Content-Type'])) {
      $header = new MailinglistHeader($this->headers['Content-Type']);
      $ct = $header->get_atom();
      $pos = strpos($ct, '/');
      if (!$pos) {
        $this->logError('Bad Content-Type Format', $ct);
        $pos = 0;
      }
      $type = substr($ct, 0, $pos);
      $subtype = substr($ct, $pos+1);
      $header->get_char();  // Remove the terminator (;) on the atom.
      $parms = array();
      // Get parameters to Content-Type
      while ($parm = $header->get_token()) {
        $char = $header->get_char(); // eat the =
        $value = $header->get_value();
        $parms[$parm] = $value;
      }
      switch (strtolower($type)) {
        case 'multipart':
          $bodies = explode("--" . $parms['boundary'], $this->body);
          $this->body = array();
          foreach ($bodies as $body) {
            if (!empty($body) && $body[0] == "\n" && strlen($body) > 2) {
              $this->body[] = new MailinglistMessagePart(substr($body, 1));
            }
          }
          break;
        case 'message':
          if ($subtype == 'rfc822') {
            $this->body = new MailinglistMessage($this->body);
          }
          break;

        case 'text':
          if (isset($parms['charset'])) {
            $charset = strtoupper($parms['charset']);
            if ($charset == 'US-ASCII') $charset = 'ASCII';
            $encodings = mb_list_encodings();
            $this->body = mb_convert_encoding($this->body, 'UTF-8', $charset);
          }
          break;

        default:
          $this->logError('Unkown Content Type ' . $type . ' / ' . $subtype);
          dpm(array($type, $subtype));
      }
    }
  }

  function parseEmailAddr($addr) {
    $pos = strpos($addr, '<');
    if ($pos !== FALSE) {
      // Address uses name <email> format.
      $pos1 = strpos($addr, '>', $pos);
      $email = substr($addr, $pos+1, $pos1-$pos-2);
      if ($pos > 0) {
        $name = substr($addr, 0, $pos) . substr($addr, $pos1+1);
      }
      else {
        $name = substr($addr, $pos1+1);
      }
    }
    else {
      $pos = strpos($addr, '(');
      if ($pos !== FALSE) {
        $pos1 = strpos($addr, ')');
        $name = substr($addr, $pos+1, $pos1-$pos-1);
        if ($pos > 0) {
          $email = substr($addr, 0, $pos) . substr($addr, $pos1+1);
        }
        else {
          $email = substr($addr, $pos1+1);
        }
      }
      else {
        $email = $addr;
        $name = "";
      }
    }

    return array('email' => trim($email), 'name' => trim($name));
  }

  function stripComments($header) {
    while(FALSE !== ($pos = strpos($header, '('))) {
      $pos1 = strpos($header, ')', $pos);
      if($pos1 != FALSE) {
        $header = substr($header, 0, $pos) . ' ' . substr($header, $pos1+1);
      }
      else {
        // badly formated, strip rest of header
        $header = substr($header, 0, $pos);
      }
    }
    return $header;
  }

  function logError($str, $parm = array()) {
    dpm($str, NULL, 'error');
    watchdog('MailinglistMessage', $str, $parms, WATCHDOG_ERROR);
  }
}

class MailinglistMessage extends MailinglistMessagePart implements MailinglistMessageInterface {
  public $raw_message;
  function __construct($msg="") {
    if (is_string($msg)) {
      // Fix line endings, just in case
      $msg = str_replace(array("\n\r", "\r\n", "\r"), "\n", $msg);
      // Build up our best conversion of raw message. Problem is it may have a mixed encoding
      $rawmsg = @iconv('UTF-8//IGNORE', 'UTF-8', $msg);
      $charset="";
      if ($rawmsg != $msg) {
        $rawmsg = iconv('ISO-8859-1//IGNORE', 'UTF-8', $msg);
        $charset = 'ISO-8859-1';
      }
      $this->raw_message = $rawmsg;
      parent::__construct($msg);
      if(!empty($charset)){
        $this->setHeader('XX-RawCharset', $charset);
      }
    }
  }

  function raw() {
    return $this->raw_message;
  }
}