imap.lib

Go to the documentation of this file.

<?php
// $Id: 5996b2c311c737287ab1ba4325f2a79e978eb685 $
class IMAP {
  protected $host = 'localhost';
  protected $port = 143;
  protected $service = 'imap';
  protected $encrypt = 'none';
  protected $validate = FALSE;
  protected $mbdelim = '.';
  protected $mbuser = array('user' => 'mbuser', 'pass' => 'mbpass');
  protected $mbreadonly = FALSE;
  protected $mbflags = NULL;
  protected $mbconnstr = NULL;
  protected $mbox = NULL;
  protected $mbres = NULL;
  private $mode = NULL;
  private $check = NULL;

  function __construct ($user, $pass, $host = NULL, $port = NULL, $service = NULL, $mb_delim = NULL, $encrypt_mode = NULL, $validate_cert = NULL, $readonly = NULL) {
    $this->mbuser = array('user' => $user, 'pass' => $pass);
    if ($host) $this->host = $host;
    if ($port) $this->port = $port;
    if ($service) $this->service = $service;
    $this->encrypt = $encrypt_mode;
    $this->encrypt = ($this->encrypt === 'none' || is_null($this->encrypt)) ? FALSE : $this->encrypt;
    if ($validate_cert) $this->validate = ($validate_cert) === 'yes' ? TRUE : FALSE;
    if ($mb_delim) $this->mbdelim = $mb_delim;
    if ($readonly) $this->mbreadonly = ($readonly) === 'yes' ? TRUE : FALSE;
    $this->mbflags = '/service=' . $this->service;
    if ($this->mbreadonly) {
      $this->mbflags .= '/readonly';
    }
    if ($this->encrypt) {
      $this->mbflags .= '/' . $this->encrypt;
    }
    if ($this->validate) {
      $this->mbflags .= '/validate-cert';
    }
    else {
      $this->mbflags .= '/novalidate-cert';
    }
  }

  function __destruct() {
    $this->close();
  }

   function __set($param, $value) {
     switch ($param) {
       case 'mbox':
       case 'mailbox': {
         $this->mbox = $value;
       } break;
     }
   }

  function open($mode = 0, $force = FALSE) {
    if (!$this->mbconnstr) {
      $this->mbconnstr = '{' . $this->host . ':' . $this->port . $this->mbflags . '}';
    }
    $user =& $this->mbuser['user'];
    $pass =& $this->mbuser['pass'];
    if ($this->mbreadonly) {
      $mode |= OP_READONLY;
    }
    if ($mode & OP_HALFOPEN) {
      $mb = NULL;
    }
    else {
      $mb = $this->mbox;
    }
    if (!$force && $this->mbres) {
      imap_reopen($this->mbres, $this->mbconnstr . $mb, $mode);
      $error = $this->error();
      if ($error->type == 'CLOSED') {
        return  $this->open($mode, TRUE);
      }
    }
    else {
      if ($force && !$mode) {
        $mode == $this->mode;
      }
      else {
        $this->mode = $mode;
      }
      $this->mbres = imap_open($this->mbconnstr . $mb, $user, $pass, $mode);
    }
    if ($errors = imap_errors()) {
      foreach ($errors as $error) {
        drupal_set_message($error, 'error');
      }
    }
    return  $this->mbres;
  }

  function close() {
    $return = NULL;
    if (is_resource($this->mbres)) $return = imap_close($this->mbres);
    return $return;
  }

  function check($mbox_name = NULL) {
    $this->check_mbox($mbox_name);
    return imap_check($this->mbres);
  }

  function status($mbox_name = NULL, $options = SA_ALL) {
    $this->check_mbox($mbox_name);
    $mbox = $this->mbconnstr . $this->mbox;
    return imap_status($this->mbres, $mbox, $options);
  }

  function fetch_overview($messages, $mbox_name = NULL) {
    $this->check_mbox($mbox_name);
    watchdog('imap debug', print_r($messages, true));
    return imap_fetch_overview($this->mbres, $messages, 0);
  }

  function list_headers($mbox_name) {
    $headers = array();
    $this->check_mbox($mbox_name);
    $check = imap_check($this->mbres);
    $headers = imap_fetch_overview($this->mbres, "1:{$check->Nmsgs}", 0);
    return $headers;
  }

  /*
   * Delete the mailbox item.
   *
   * @param $msgno
   * - The message sequence number.
   *
   * @return
   * - The result of the delete, TRUE or FALSE.
   */
  function delete_item($msgno) {
    return imap_delete($this->mbres, $msgno);
  }

  function copy_item($msgno, $to_folder) {
    return imap_mail_copy($this->mbres, $msgno, $to_folder);
  }

  function move_item($msgno, $to_folder) {
    return imap_mail_move($this->mbres, $msgno, $to_folder);
  }

  function expunge($mbox_name = NULL) {
    $this->check_mbox($mbox_name);
    return imap_expunge($this->mbres);
  }

  function headerinfo($msgno) {
    static $except = FALSE;
    $fetch = imap_headerinfo($this->mbres, $msgno);
    $error = $this->error();
    if ($error) {
      switch ($error->type) {
        case 'CLOSED': {
          if (!$except) {
            $this->open(0, TRUE);
            $except = TRUE;
            return $this->headerinfo($msgno);
          }
          else {
            throw new Exception($error->text);
          }
        } break;
        case 'WARNING': {
          //ignore.
        } break;
        default: {
          throw new Exception($error->text);
        } break;
      }
    }
    $except = FALSE;
    return $fetch;
  }

  function fetchheader($msgno) {
    static $except = FALSE;
    $fetch = imap_fetchheader($this->mbres, $msgno);
    $error = $this->error();
    if ($error) {
      switch ($error->type) {
        case 'CLOSED': {
          if (!$except) {
            $this->open(0, TRUE);
            $except = TRUE;
            return $this->fetchheader($msgno);
          }
          else {
            throw new Exception($error->text);
          }
        } break;
        case 'WARNING': {
          //ignore.
        } break;
        default: {
          throw new Exception($error->text);
        } break;
      }
    }
    $except = FALSE;
    return $fetch;
  }

  function fetchstructure($msgno) {
    static $except = FALSE;
    $fetch = imap_fetchstructure($this->mbres, $msgno);
    $error = $this->error();
    if ($error) {
      switch ($error->type) {
        case 'CLOSED': {
          if (!$except) {
            $this->open(0, TRUE);
            $except = TRUE;
            return $this->fetchstructure($msgno);
          }
          else {
            throw new Exception($error->text);
          }
        } break;
        case 'WARNING': {
          //ignore.
        } break;
        default: {
          throw new Exception($error->text);
        } break;
      }
    }
    $except = FALSE;
    return $fetch;
  }

  function bodystruct($msgno, $partno) {
    static $except = FALSE;
    $fetch = imap_bodystruct($this->mbres, $msgno, $partno);
    $error = $this->error();
    if ($error) {
      switch ($error->type) {
        case 'CLOSED': {
          if (!$except) {
            $this->open(0, TRUE);
            $except = TRUE;
            return $this->bodystruct($msgno, $partno);
          }
          else {
            throw new Exception($error->text);
          }
        } break;
        case 'WARNING': {
          //ignore.
        } break;
        default: {
          throw new Exception($error->text);
        } break;
      }
    }
    $except = FALSE;
    return $fetch;
  }

  function list_mbox($mbox) {
    $mboxes = imap_getmailboxes($this->mbres, $this->mbconnstr, $mbox);
    if (count($mboxes) === 0) {
      return FALSE;
    }
    elseif (count($mboxes) > 1) {
      throw new Exception('Invalid mailbox specification.');
    }
    $mbx =& $mboxes[0];
    $status = imap_status($this->mbres, $this->mbconnstr . $mbox, SA_ALL);
    foreach ((array)$status as $key => $stat) {
      $mbx->$key = $stat;
    }
    return $mbx;
  }

  function list_mboxes() {
    $mboxes = imap_getmailboxes($this->mbres, $this->mbconnstr, '*');
    $return = array();
    foreach ($mboxes as $mbox) {
      list(,$mbox) = explode('}', $mbox->name);
      $return[] = $this->list_mbox($mbox);
    }
    return $return;
  }

  function fetch_item($msgno, $mime_part = 'TEXT/PLAIN', $parts = NULL) {
    if (is_null($parts)) {
      $structure = imap_fetchstructure($this->mbres, $msgno);
      $parts = $this->parts($structure, $msgno);
      return $this->fetch_item($msgno, $mime_part, $parts);
    }
    else {
      $ret = NULL;
      foreach ($parts as $part) {
        if ($part->mime_type === $mime_part) {
          $ret .= "\r\n\r\n" . $part->text;
        }
        elseif ($mime_part == 'ATTACHMENT' &&
          $part->disposition == 'attachment')
        {
          $att = new stdClass;
          $att->subtype = $att->filename = $att->name = NULL;
          $att->subtype = $part->subtype;
          if ($part->dparameters) {
            $att->{$part->dparameters[0]->attribute} = $part->dparameters[0]->value;
          }
          if ($part->parameters) {
            $att->{$part->parameters[0]->attribute} = $part->parameters[0]->value;
          }
          $att->contents = $part->text;
          $ret[] = $att;
        }
      }
      return $ret;
    }
  }

  private function parts($structure, $msgno, $partno = FALSE) {
    if ($structure) {
      $parts = array();
      if (!$structure->parts) {
        if ($partno === FALSE) {
          $partno = '1';
        }
        $body = imap_fetchbody($this->mbres, $msgno, $partno);
        $bodystruct = imap_bodystruct($this->mbres, $msgno, $partno);
        $body = $this->part_decode($bodystruct->encoding, $body);
        if ($bodystruct->ifparameters) {
          foreach ($bodystruct->parameters as $parameter) {
            if (strtolower($parameter->attribute) == 'charset') {
              $body = iconv($parameter->value, 'utf-8', $body);
              break;
            }
          }
        }
        $part = new stdClass;
        $part->partno = $partno;
        $part->mime_type = $this->mime_type($bodystruct);
        $part->text = $body;
        $part->bytes = $bodystruct->bytes;
        $part->subtype = $bodystruct->ifsubtype ? $bodystruct->subtype : NULL;
        $part->disposition = $bodystruct->ifdisposition ? $bodystruct->disposition : NULL;
        $part->dparameters = $bodystruct->ifdparameters ? $bodystruct->dparameters : NULL;
        $part->parameters = $bodystruct->ifparameters ? $bodystruct->parameters : NULL;
        $parts[$partno] = $part;
      }
      else {
        while (list($index, $substructure) = each($structure->parts)) {
          if ($partno) {
            $prefix = $partno . '.';
          }
          else {
            $prefix = NULL;
          }
          $data = $this->parts($substructure, $msgno, $prefix . ($index + 1));
          $parts += $data;
        }
      }
      return $parts;
    }
    return FALSE;
  }

  private function part_decode($encoding, $text) {
    switch ($encoding) {
      case 3: {
        return imap_base64($text);
      } break;
      case 4: {
        return quoted_printable_decode($text); // This resolved and issue of NULL being returned with imap_qprint
        return imap_qprint($text);
      } break;
      default: {
        return $text;
      } break;
    }
  }

  private function mime_type($structure) {
    $primary_mime_types = array('TEXT', 'MULTIPART', 'MESSAGE', 'APPLICATION', 'AUDIO', 'IMAGE', 'VIDEO', 'OTHER');
    if ($structure->subtype) {
      $mime_type = $primary_mime_types[$structure->type] . '/' . $structure->subtype;
    }
    else {
      $mime_type = "TEXT/PLAIN";
    }
    return $mime_type;
  }

  private function error() {
    $text = imap_last_error();
    if ($text === FALSE) {
      return $text;
    }
    $parts = explode(' ', strtolower($text));
    switch ($parts[0]) {
      case 'warning:': {
        $type = 'WARNING';
      } break;
      case 'unexpected': {
        $type = 'WARNING';
      } break;
      case 'unterminated': {
        $type = 'WARNING';
      } break;
      case '[closed]': {
        $type = 'CLOSED';
      } break;
      case 'invalid': {
        if ($parts[1] === 'mailbox' && $parts[2] === 'list:' && $parts[3] === '<>') {
          $type = 'WARNING';
        }
        else {
          $type = 'UNKNOWN';
        }
      } break;
      case 'must': {
        if ($parts[1] === 'use' && $parts[2] === 'comma') {
          $type = 'WARNING';
        }
        else {
          $type = 'UNKNOWN';
        }
      } break;
      case 'no': {
        if ($parts[1] === 'body' && $parts[2] === 'information') {
          $type = 'WARNING';
        }
        else {
          $type = 'UNKNOWN';
        }
      } break;
      case 'store': {
        if ($parts[3] === 'read-only') {
          $type = 'WARNING';
        }
        else {
          $type = 'UNKNOWN';
        }
      } break;
      default: {
        $type = 'UNKNOWN';
      } break;
    }
    $error->type = $type;
    $error->text = $text;
    return $error;
  }

  private function check_mbox($mbox_name, $open_mode = OP_READONLY) {
    if ($mbox_name) {
      if ($mbox_name != $this->mbox) {
        $this->mbox = $mbox_name;
        $this->open($open_mode);
      }
    }
  }

}