* - alert: (string) Alert string.
* - type: (string) [OPTIONAL] Alert type.
*
*/
public function getLast()
{
return $this->_alert;
}
/* SplSubject methods. */
/**
*/
public function attach(SplObserver $observer)
{
$this->detach($observer);
$this->_observers[] = $observer;
}
/**
*/
public function detach(SplObserver $observer)
{
if (($key = array_search($observer, $this->_observers, true)) !== false) {
unset($this->_observers[$key]);
}
}
/**
* Notification is triggered internally whenever the object's internal
* data storage is altered.
*/
public function notify()
{
foreach ($this->_observers as $val) {
$val->update($this);
}
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Base/Debug.php 0000664 0001750 0001750 00000006565 13150761653 021652 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @internal
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Base_Debug
{
/** Time, in seconds, to be labeled a slow command. */
const SLOW_CMD = 5;
/**
* Is debugging active?
*
* @var boolean
*/
public $debug = true;
/**
* The debug stream.
*
* @var resource
*/
protected $_stream;
/**
* Timestamp of last command.
*
* @var integer
*/
protected $_time = null;
/**
* Constructor.
*
* @param mixed $debug The debug target.
*/
public function __construct($debug)
{
$this->_stream = is_resource($debug)
? $debug
: @fopen($debug, 'a');
register_shutdown_function(array($this, 'shutdown'));
}
/**
* Shutdown function.
*/
public function shutdown()
{
if (is_resource($this->_stream)) {
fflush($this->_stream);
fclose($this->_stream);
$this->_stream = null;
}
}
/**
* Write client output to debug log.
*
* @param string $msg Debug message.
*/
public function client($msg)
{
$this->_write($msg . "\n", 'C: ');
}
/**
* Write informational message to debug log.
*
* @param string $msg Debug message.
*/
public function info($msg)
{
$this->_write($msg . "\n", '>> ');
}
/**
* Write server output to debug log.
*
* @param string $msg Debug message.
*/
public function raw($msg)
{
$this->_write($msg);
}
/**
* Write server output to debug log.
*
* @param string $msg Debug message.
*/
public function server($msg)
{
$this->_write($msg . "\n", 'S: ');
}
/**
* Write debug information to the output stream.
*
* @param string $msg Debug data.
*/
protected function _write($msg, $pre = null)
{
if (!$this->debug || !$this->_stream) {
return;
}
if (!is_null($pre)) {
$new_time = microtime(true);
if (is_null($this->_time)) {
fwrite(
$this->_stream,
str_repeat('-', 30) . "\n" . '>> ' . date('r') . "\n"
);
} elseif (($diff = ($new_time - $this->_time)) > self::SLOW_CMD) {
fwrite(
$this->_stream,
'>> Slow Command: ' . round($diff, 3) . " seconds\n"
);
}
$this->_time = $new_time;
}
fwrite($this->_stream, $pre . $msg);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Base/Deprecated.php 0000664 0001750 0001750 00000007035 13150761653 022655 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @internal
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Base_Deprecated
{
/**
* Returns a unique identifier for the current mailbox status.
*
* @param Horde_Imap_Client_Base $base_ob The base driver object.
* @param mixed $mailbox A mailbox. Either a
* Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param boolean $condstore Is CONDSTORE enabled?
* @param array $addl Additional cache info to add to
* the cache ID string.
*
* @return string The cache ID string, which will change when the
* composition of the mailbox changes. The uidvalidity
* will always be the first element, and will be delimited
* by the '|' character.
*
* @throws Horde_Imap_Client_Exception
*/
public static function getCacheId($base_ob, $mailbox, $condstore,
array $addl = array())
{
$query = Horde_Imap_Client::STATUS_UIDVALIDITY | Horde_Imap_Client::STATUS_MESSAGES | Horde_Imap_Client::STATUS_UIDNEXT;
/* Use MODSEQ as cache ID if CONDSTORE extension is available. */
if ($condstore) {
$query |= Horde_Imap_Client::STATUS_HIGHESTMODSEQ;
} else {
$query |= Horde_Imap_Client::STATUS_UIDNEXT_FORCE;
}
$status = $base_ob->status($mailbox, $query);
if (empty($status['highestmodseq'])) {
$parts = array(
'V' . $status['uidvalidity'],
'U' . $status['uidnext'],
'M' . $status['messages']
);
} else {
$parts = array(
'V' . $status['uidvalidity'],
'H' . $status['highestmodseq']
);
}
return implode('|', array_merge($parts, $addl));
}
/**
* Parses a cacheID created by getCacheId().
*
* @param string $id The cache ID.
*
* @return array An array with the following information:
* - highestmodseq: (integer)
* - messages: (integer)
* - uidnext: (integer)
* - uidvalidity: (integer) Always present
*/
public static function parseCacheId($id)
{
$data = array(
'H' => 'highestmodseq',
'M' => 'messages',
'U' => 'uidnext',
'V' => 'uidvalidity'
);
$info = array();
foreach (explode('|', $id) as $part) {
if (isset($data[$part[0]])) {
$info[$data[$part[0]]] = intval(substr($part, 1));
}
}
return $info;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Base/Mailbox.php 0000664 0001750 0001750 00000012516 13150761653 022210 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @internal
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Base_Mailbox
{
/**
* Mapping object.
*
* @var Horde_Imap_Client_Ids_Map
*/
public $map;
/**
* Is mailbox opened?
*
* @var boolean
*/
public $open;
/**
* Is mailbox sync'd with remote server (via CONDSTORE/QRESYNC)?
*
* @var boolean
*/
public $sync;
/**
* Status information.
*
* @var array
*/
protected $_status = array();
/**
* Constructor.
*/
public function __construct()
{
$this->reset();
}
/**
* Get status information for the mailbox.
*
* @param integer $entry STATUS_* constant.
*
* @return mixed Status information.
*/
public function getStatus($entry)
{
if (isset($this->_status[$entry])) {
return $this->_status[$entry];
}
switch ($entry) {
case Horde_Imap_Client::STATUS_FLAGS:
case Horde_Imap_Client::STATUS_SYNCFLAGUIDS:
case Horde_Imap_Client::STATUS_SYNCVANISHED:
return array();
case Horde_Imap_Client::STATUS_FIRSTUNSEEN:
/* If we know there are no messages in the current mailbox, we
* know there are no unseen messages. */
return empty($this->_status[Horde_Imap_Client::STATUS_MESSAGES])
? false
: null;
case Horde_Imap_Client::STATUS_RECENT_TOTAL:
case Horde_Imap_Client::STATUS_SYNCMODSEQ:
return 0;
case Horde_Imap_Client::STATUS_PERMFLAGS:
/* If PERMFLAGS is not returned by server, must assume that all
* flags can be changed permanently (RFC 3501 [6.3.1]). */
$flags = isset($this->_status[Horde_Imap_Client::STATUS_FLAGS])
? $this->_status[Horde_Imap_Client::STATUS_FLAGS]
: array();
$flags[] = "\\*";
return $flags;
case Horde_Imap_Client::STATUS_UIDNOTSTICKY:
/* In the absence of explicit uidnotsticky identification, assume
* that UIDs are sticky. */
return false;
case Horde_Imap_Client::STATUS_UNSEEN:
/* If we know there are no messages in the current mailbox, we
* know there are no unseen messages . */
return empty($this->_status[Horde_Imap_Client::STATUS_MESSAGES])
? 0
: null;
default:
return null;
}
}
/**
* Set status information for the mailbox.
*
* @param integer $entry STATUS_* constant.
* @param mixed $value Status information.
*/
public function setStatus($entry, $value)
{
switch ($entry) {
case Horde_Imap_Client::STATUS_FIRSTUNSEEN:
case Horde_Imap_Client::STATUS_HIGHESTMODSEQ:
case Horde_Imap_Client::STATUS_MESSAGES:
case Horde_Imap_Client::STATUS_UNSEEN:
case Horde_Imap_Client::STATUS_UIDNEXT:
case Horde_Imap_Client::STATUS_UIDVALIDITY:
$value = intval($value);
break;
case Horde_Imap_Client::STATUS_RECENT:
/* Keep track of RECENT_TOTAL information. */
$this->_status[Horde_Imap_Client::STATUS_RECENT_TOTAL] = isset($this->_status[Horde_Imap_Client::STATUS_RECENT_TOTAL])
? ($this->_status[Horde_Imap_Client::STATUS_RECENT_TOTAL] + $value)
: intval($value);
break;
case Horde_Imap_Client::STATUS_SYNCMODSEQ:
/* This is only set once per access. */
if (isset($this->_status[$entry])) {
return;
}
$value = intval($value);
break;
case Horde_Imap_Client::STATUS_SYNCFLAGUIDS:
case Horde_Imap_Client::STATUS_SYNCVANISHED:
if (!isset($this->_status[$entry])) {
$this->_status[$entry] = array();
}
$this->_status[$entry] = array_merge($this->_status[$entry], $value);
return;
}
$this->_status[$entry] = $value;
}
/**
* Reset the mailbox information.
*/
public function reset()
{
$keep = array(
Horde_Imap_Client::STATUS_SYNCFLAGUIDS,
Horde_Imap_Client::STATUS_SYNCMODSEQ,
Horde_Imap_Client::STATUS_SYNCVANISHED
);
foreach (array_diff(array_keys($this->_status), $keep) as $val) {
unset($this->_status[$val]);
}
$this->map = new Horde_Imap_Client_Ids_Map();
$this->open = $this->sync = false;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Base/Password.php 0000664 0001750 0001750 00000001520 13150761653 022410 0 ustar jan jan
* @category Horde
* @copyright 2013-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.14.0
*/
interface Horde_Imap_Client_Base_Password
{
/**
* Return the password to use for the server connection.
*
* @return string The password.
*/
public function getPassword();
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Cache/Backend/Cache.php 0000664 0001750 0001750 00000034521 13150761653 023300 0 ustar jan jan
* @category Horde
* @copyright 2005-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Cache_Backend_Cache
extends Horde_Imap_Client_Cache_Backend
{
/** Cache structure version. */
const VERSION = 3;
/**
* The cache object.
*
* @var Horde_Cache
*/
protected $_cache;
/**
* The working data for the current pageload. All changes take place to
* this data.
*
* @var array
*/
protected $_data = array();
/**
* The list of cache slices loaded.
*
* @var array
*/
protected $_loaded = array();
/**
* The mapping of UIDs to slices.
*
* @var array
*/
protected $_slicemap = array();
/**
* The list of items to update:
* - add: (array) List of IDs that were added.
* - slice: (array) List of slices that were modified.
* - slicemap: (boolean) Was slicemap info changed?
*
* @var array
*/
protected $_update = array();
/**
* Constructor.
*
* @param array $params Configuration parameters:
*
* - REQUIRED Parameters:
* - cacheob: (Horde_Cache) The cache object to use.
*
* - Optional Parameters:
* - lifetime: (integer) The lifetime of the cache data (in seconds).
* DEFAULT: 1 week (604800 seconds)
* - slicesize: (integer) The slicesize to use.
* DEFAULT: 50
*
*/
public function __construct(array $params = array())
{
// Default parameters.
$params = array_merge(array(
'lifetime' => 604800,
'slicesize' => 50
), array_filter($params));
if (!isset($params['cacheob'])) {
throw new InvalidArgumentException('Missing cacheob parameter.');
}
foreach (array('lifetime', 'slicesize') as $val) {
$params[$val] = intval($params[$val]);
}
parent::__construct($params);
}
/**
* Initialization tasks.
*/
protected function _initOb()
{
$this->_cache = $this->_params['cacheob'];
register_shutdown_function(array($this, 'save'));
}
/**
* Updates the cache.
*/
public function save()
{
$lifetime = $this->_params['lifetime'];
foreach ($this->_update as $mbox => $val) {
$s = &$this->_slicemap[$mbox];
try {
if (!empty($val['add'])) {
if ($s['c'] <= $this->_params['slicesize']) {
$val['slice'][] = $s['i'];
$this->_loadSlice($mbox, $s['i']);
}
$val['slicemap'] = true;
foreach (array_keys(array_flip($val['add'])) as $uid) {
if ($s['c']++ > $this->_params['slicesize']) {
$s['c'] = 0;
$val['slice'][] = ++$s['i'];
$this->_loadSlice($mbox, $s['i']);
}
$s['s'][$uid] = $s['i'];
}
}
if (!empty($val['slice'])) {
$d = &$this->_data[$mbox];
$val['slicemap'] = true;
foreach (array_keys(array_flip($val['slice'])) as $slice) {
$data = array();
foreach (array_keys($s['s'], $slice) as $uid) {
$data[$uid] = is_array($d[$uid])
? serialize($d[$uid])
: $d[$uid];
}
$this->_cache->set($this->_getCid($mbox, $slice), serialize($data), $lifetime);
}
}
if (!empty($val['slicemap'])) {
$this->_cache->set($this->_getCid($mbox, 'slicemap'), serialize($s), $lifetime);
}
} catch (Horde_Exception $e) {
}
}
$this->_update = array();
}
/**
*/
public function get($mailbox, $uids, $fields, $uidvalid)
{
$ret = array();
$this->_loadUids($mailbox, $uids, $uidvalid);
if (empty($this->_data[$mailbox])) {
return $ret;
}
if (!empty($fields)) {
$fields = array_flip($fields);
}
$ptr = &$this->_data[$mailbox];
foreach (array_intersect($uids, array_keys($ptr)) as $val) {
if (is_string($ptr[$val])) {
try {
$ptr[$val] = @unserialize($ptr[$val]);
} catch (Exception $e) {}
}
$ret[$val] = (empty($fields) || empty($ptr[$val]))
? $ptr[$val]
: array_intersect_key($ptr[$val], $fields);
}
return $ret;
}
/**
*/
public function getCachedUids($mailbox, $uidvalid)
{
$this->_loadSliceMap($mailbox, $uidvalid);
return array_unique(array_merge(
array_keys($this->_slicemap[$mailbox]['s']),
(isset($this->_update[$mailbox]) ? $this->_update[$mailbox]['add'] : array())
));
}
/**
*/
public function set($mailbox, $data, $uidvalid)
{
$update = array_keys($data);
try {
$this->_loadUids($mailbox, $update, $uidvalid);
} catch (Horde_Imap_Client_Exception $e) {
// Ignore invalidity - just start building the new cache
}
$d = &$this->_data[$mailbox];
$s = &$this->_slicemap[$mailbox]['s'];
$add = $updated = array();
foreach ($data as $k => $v) {
if (isset($d[$k])) {
if (is_string($d[$k])) {
try {
$d[$k] = @unserialize($d[$k]);
} catch (Exception $e) {}
}
$d[$k] = is_array($d[$k])
? array_merge($d[$k], $v)
: $v;
if (isset($s[$k])) {
$updated[$s[$k]] = true;
}
} else {
$d[$k] = $v;
$add[] = $k;
}
}
$this->_toUpdate($mailbox, 'add', $add);
$this->_toUpdate($mailbox, 'slice', array_keys($updated));
}
/**
*/
public function getMetaData($mailbox, $uidvalid, $entries)
{
$this->_loadSliceMap($mailbox, $uidvalid);
return empty($entries)
? $this->_slicemap[$mailbox]['d']
: array_intersect_key($this->_slicemap[$mailbox]['d'], array_flip($entries));
}
/**
*/
public function setMetaData($mailbox, $data)
{
$this->_loadSliceMap($mailbox, isset($data['uidvalid']) ? $data['uidvalid'] : null);
$this->_slicemap[$mailbox]['d'] = array_merge($this->_slicemap[$mailbox]['d'], $data);
$this->_toUpdate($mailbox, 'slicemap', true);
}
/**
*/
public function deleteMsgs($mailbox, $uids)
{
if (empty($uids)) {
return;
}
$this->_loadSliceMap($mailbox);
$slicemap = &$this->_slicemap[$mailbox];
$deleted = array_intersect_key($slicemap['s'], array_flip($uids));
if (isset($this->_update[$mailbox])) {
$this->_update[$mailbox]['add'] = array_diff(
$this->_update[$mailbox]['add'],
$uids
);
}
if (empty($deleted)) {
return;
}
$this->_loadUids($mailbox, array_keys($deleted));
$d = &$this->_data[$mailbox];
foreach (array_keys($deleted) as $id) {
unset($d[$id], $slicemap['s'][$id]);
}
foreach (array_unique($deleted) as $slice) {
/* Get rid of slice if less than 10% of capacity. */
if (($slice != $slicemap['i']) &&
($slice_uids = array_keys($slicemap['s'], $slice)) &&
($this->_params['slicesize'] * 0.1) > count($slice_uids)) {
$this->_toUpdate($mailbox, 'add', $slice_uids);
$this->_cache->expire($this->_getCid($mailbox, $slice));
foreach ($slice_uids as $val) {
unset($slicemap['s'][$val]);
}
} else {
$this->_toUpdate($mailbox, 'slice', array($slice));
}
}
}
/**
*/
public function deleteMailbox($mailbox)
{
$this->_loadSliceMap($mailbox);
$this->_deleteMailbox($mailbox);
}
/**
*/
public function clear($lifetime)
{
$this->_cache->clear();
$this->_data = $this->_loaded = $this->_slicemap = $this->_update = array();
}
/**
* Create the unique ID used to store the data in the cache.
*
* @param string $mailbox The mailbox to cache.
* @param string $slice The cache slice.
*
* @return string The cache ID.
*/
protected function _getCid($mailbox, $slice)
{
return implode('|', array(
'horde_imap_client',
$this->_params['username'],
$mailbox,
$this->_params['hostspec'],
$this->_params['port'],
$slice,
self::VERSION
));
}
/**
* Delete a mailbox from the cache.
*
* @param string $mbox The mailbox to delete.
*/
protected function _deleteMailbox($mbox)
{
foreach (array_merge(array_keys(array_flip($this->_slicemap[$mbox]['s'])), array('slicemap')) as $slice) {
$cid = $this->_getCid($mbox, $slice);
$this->_cache->expire($cid);
unset($this->_loaded[$cid]);
}
unset(
$this->_data[$mbox],
$this->_slicemap[$mbox],
$this->_update[$mbox]
);
}
/**
* Load UIDs by regenerating from the cache.
*
* @param string $mailbox The mailbox to load.
* @param array $uids The UIDs to load.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*/
protected function _loadUids($mailbox, $uids, $uidvalid = null)
{
if (!isset($this->_data[$mailbox])) {
$this->_data[$mailbox] = array();
}
$this->_loadSliceMap($mailbox, $uidvalid);
if (!empty($uids)) {
foreach (array_unique(array_intersect_key($this->_slicemap[$mailbox]['s'], array_flip($uids))) as $slice) {
$this->_loadSlice($mailbox, $slice);
}
}
}
/**
* Load UIDs from a cache slice.
*
* @param string $mailbox The mailbox to load.
* @param integer $slice The slice to load.
*/
protected function _loadSlice($mailbox, $slice)
{
$cache_id = $this->_getCid($mailbox, $slice);
if (!empty($this->_loaded[$cache_id])) {
return;
}
if (($data = $this->_cache->get($cache_id, 0)) !== false) {
try {
$data = @unserialize($data);
} catch (Exception $e) {}
}
if (($data !== false) && is_array($data)) {
$this->_data[$mailbox] += $data;
$this->_loaded[$cache_id] = true;
} else {
$ptr = &$this->_slicemap[$mailbox];
// Slice data is corrupt; remove from slicemap.
foreach (array_keys($ptr['s'], $slice) as $val) {
unset($ptr['s'][$val]);
}
if ($slice == $ptr['i']) {
$ptr['c'] = 0;
}
}
}
/**
* Load the slicemap for a given mailbox. The slicemap contains
* the uidvalidity information, the UIDs->slice lookup table, and any
* metadata that needs to be saved for the mailbox.
*
* @param string $mailbox The mailbox.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*/
protected function _loadSliceMap($mailbox, $uidvalid = null)
{
if (!isset($this->_slicemap[$mailbox]) &&
(($data = $this->_cache->get($this->_getCid($mailbox, 'slicemap'), 0)) !== false)) {
try {
if (($slice = @unserialize($data)) &&
is_array($slice)) {
$this->_slicemap[$mailbox] = $slice;
}
} catch (Exception $e) {}
}
if (isset($this->_slicemap[$mailbox])) {
$ptr = &$this->_slicemap[$mailbox];
if (is_null($ptr['d']['uidvalid'])) {
$ptr['d']['uidvalid'] = $uidvalid;
return;
} elseif (!is_null($uidvalid) &&
($ptr['d']['uidvalid'] != $uidvalid)) {
$this->_deleteMailbox($mailbox);
} else {
return;
}
}
$this->_slicemap[$mailbox] = array(
// Tracking count for purposes of determining slices
'c' => 0,
// Metadata storage
// By default includes UIDVALIDITY of mailbox.
'd' => array('uidvalid' => $uidvalid),
// The ID of the last slice.
'i' => 0,
// The slice list.
's' => array()
);
}
/**
* Add update entry for a mailbox.
*
* @param string $mailbox The mailbox.
* @param string $type 'add', 'slice', or 'slicemap'.
* @param mixed $data The data to update.
*/
protected function _toUpdate($mailbox, $type, $data)
{
if (!isset($this->_update[$mailbox])) {
$this->_update[$mailbox] = array(
'add' => array(),
'slice' => array()
);
}
$this->_update[$mailbox][$type] = ($type == 'slicemap')
? $data
: array_merge($this->_update[$mailbox][$type], $data);
}
/* Serializable methods. */
/**
*/
public function serialize()
{
$this->save();
return parent::serialize();
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Cache/Backend/Db.php 0000664 0001750 0001750 00000027224 13150761653 022624 0 ustar jan jan
* @category Horde
* @copyright 2013-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Cache_Backend_Db
extends Horde_Imap_Client_Cache_Backend
{
/** SQL table names. */
const BASE_TABLE = 'horde_imap_client_data';
const MD_TABLE = 'horde_imap_client_metadata';
const MSG_TABLE = 'horde_imap_client_message';
/**
* Handle for the database connection.
*
* @var Horde_Db_Adapter
*/
protected $_db;
/**
* Constructor.
*
* @param array $params Configuration parameters:
*
* - REQUIRED Parameters:
* - db: (Horde_Db_Adapter) DB object.
*
*/
public function __construct(array $params = array())
{
if (!isset($params['db'])) {
throw new InvalidArgumentException('Missing db parameter.');
}
parent::__construct($params);
}
/**
*/
protected function _initOb()
{
$this->_db = $this->_params['db'];
}
/**
*/
public function get($mailbox, $uids, $fields, $uidvalid)
{
$this->getMetaData($mailbox, $uidvalid, array('uidvalid'));
$query = $this->_baseSql($mailbox, self::MSG_TABLE);
$query[0] = 'SELECT t.data, t.msguid ' . $query[0];
$uid_query = array();
foreach ($uids as $val) {
$uid_query[] = 't.msguid = ?';
$query[1][] = strval($val);
}
$query[0] .= ' AND (' . implode(' OR ', $uid_query) . ')';
$compress = new Horde_Compress_Fast();
$out = array();
try {
$columns = $this->_db->columns(self::MSG_TABLE);
$res = $this->_db->select($query[0], $query[1]);
foreach ($res as $row) {
try {
$out[$row['msguid']] = @unserialize($compress->decompress(
$columns['data']->binaryToString($row['data'])
));
} catch (Exception $e) {}
}
} catch (Horde_Db_Exception $e) {}
return $out;
}
/**
*/
public function getCachedUids($mailbox, $uidvalid)
{
$this->getMetaData($mailbox, $uidvalid, array('uidvalid'));
$query = $this->_baseSql($mailbox, self::MSG_TABLE);
$query[0] = 'SELECT DISTINCT t.msguid ' . $query[0];
try {
return $this->_db->selectValues($query[0], $query[1]);
} catch (Horde_Db_Exception $e) {
return array();
}
}
/**
*/
public function set($mailbox, $data, $uidvalid)
{
if ($uid = $this->_getUid($mailbox)) {
$res = $this->get($mailbox, array_keys($data), array(), $uidvalid);
} else {
$res = array();
$uid = $this->_createUid($mailbox);
}
$compress = new Horde_Compress_Fast();
foreach ($data as $key => $val) {
if (isset($res[$key])) {
try {
/* Update */
$this->_db->updateBlob(
self::MSG_TABLE,
array('data' => new Horde_Db_Value_Binary($compress->compress(serialize(array_merge($res[$key], $val))))),
array(
'messageid = ? AND msguid = ?',
array($uid, strval($key))
)
);
} catch (Horde_Db_Exception $e) {}
} else {
/* Insert */
try {
$this->_db->insertBlob(
self::MSG_TABLE,
array(
'data' => new Horde_Db_Value_Binary($compress->compress(serialize($val))),
'msguid' => strval($key),
'messageid' => $uid
)
);
} catch (Horde_Db_Exception $e) {}
}
}
/* Update modified time. */
try {
$this->_db->update(
sprintf(
'UPDATE %s SET modified = ? WHERE messageid = ?',
self::BASE_TABLE
),
array(time(), $uid)
);
} catch (Horde_Db_Exception $e) {}
/* Update uidvalidity. */
$this->setMetaData($mailbox, array('uidvalid' => $uidvalid));
}
/**
*/
public function getMetaData($mailbox, $uidvalid, $entries)
{
$query = $this->_baseSql($mailbox, self::MD_TABLE);
$query[0] = 'SELECT t.field, t.data ' . $query[0];
if (!empty($entries)) {
$entries[] = 'uidvalid';
$entry_query = array();
foreach (array_unique($entries) as $val) {
$entry_query[] = 't.field = ?';
$query[1][] = $val;
}
$query[0] .= ' AND (' . implode(' OR ', $entry_query) . ')';
}
try {
if ($res = $this->_db->selectAssoc($query[0], $query[1])) {
$columns = $this->_db->columns(self::MD_TABLE);
foreach ($res as $key => $val) {
switch ($key) {
case 'uidvalid':
$res[$key] = $columns['data']->binaryToString($val);
break;
default:
try {
$res[$key] = @unserialize(
$columns['data']->binaryToString($val)
);
} catch (Exception $e) {}
break;
}
}
if (is_null($uidvalid) ||
!isset($res['uidvalid']) ||
($res['uidvalid'] == $uidvalid)) {
return $res;
}
$this->deleteMailbox($mailbox);
}
} catch (Horde_Db_Exception $e) {}
return array();
}
/**
*/
public function setMetaData($mailbox, $data)
{
if (!($uid = $this->_getUid($mailbox))) {
$uid = $this->_createUid($mailbox);
}
$query = sprintf('SELECT field FROM %s where messageid = ?', self::MD_TABLE);
$values = array($uid);
try {
$fields = $this->_db->selectValues($query, $values);
} catch (Horde_Db_Exception $e) {
return;
}
foreach ($data as $key => $val) {
$val = new Horde_Db_Value_Binary(($key == 'uidvalid') ? $val : serialize($val));
if (in_array($key, $fields)) {
/* Update */
try {
$this->_db->updateBlob(
self::MD_TABLE,
array('data' => $val),
array('field = ? AND messageid = ?', array($key, $uid))
);
} catch (Horde_Db_Exception $e) {}
} else {
/* Insert */
try {
$this->_db->insertBlob(
self::MD_TABLE,
array('data' => $val, 'field' => $key, 'messageid' => $uid)
);
} catch (Horde_Db_Exception $e) {}
}
}
}
/**
*/
public function deleteMsgs($mailbox, $uids)
{
if (empty($uids)) {
return;
}
$query = $this->_baseSql($mailbox);
$query[0] = sprintf(
'DELETE FROM %s WHERE messageid IN (SELECT messageid ' . $query[0] . ')',
self::MSG_TABLE
);
$uid_query = array();
foreach ($uids as $val) {
$uid_query[] = 'msguid = ?';
$query[1][] = strval($val);
}
$query[0] .= ' AND (' . implode(' OR ', $uid_query) . ')';
try {
$this->_db->delete($query[0], $query[1]);
} catch (Horde_Db_Exception $e) {}
}
/**
*/
public function deleteMailbox($mailbox)
{
if (is_null($uid = $this->_getUid($mailbox))) {
return;
}
foreach (array(self::BASE_TABLE, self::MD_TABLE, self::MSG_TABLE) as $val) {
try {
$this->_db->delete(
sprintf('DELETE FROM %s WHERE messageid = ?', $val),
array($uid)
);
} catch (Horde_Db_Exception $e) {}
}
}
/**
*/
public function clear($lifetime)
{
if (is_null($lifetime)) {
try {
$this->_db->delete(sprintf('DELETE FROM %s', self::BASE_TABLE));
$this->_db->delete(sprintf('DELETE FROM %s', self::MD_TABLE));
$this->_db->delete(sprintf('DELETE FROM %s', self::MSG_TABLE));
} catch (Horde_Db_Exception $e) {}
return;
}
$purge = time() - $lifetime;
$sql = 'DELETE FROM %s WHERE messageid IN (SELECT messageid FROM %s WHERE modified < ?)';
foreach (array(self::MD_TABLE, self::MSG_TABLE) as $val) {
try {
$this->_db->delete(
sprintf($sql, $val, self::BASE_TABLE),
array($purge)
);
} catch (Horde_Db_Exception $e) {
}
}
try {
$this->_db->delete(
sprintf('DELETE FROM %s WHERE modified < ?', self::BASE_TABLE),
array($purge)
);
} catch (Horde_Db_Exception $e) {
}
}
/**
* Prepare the base SQL query.
*
* @param string $mailbox The mailbox.
* @param string $join The table to join with the base table.
*
* @return array SQL query and bound parameters.
*/
protected function _baseSql($mailbox, $join = null)
{
$sql = sprintf('FROM %s d', self::BASE_TABLE);
if (!is_null($join)) {
$sql .= sprintf(' INNER JOIN %s t ON d.messageid = t.messageid', $join);
}
return array(
$sql . ' WHERE d.hostspec = ? AND d.port = ? AND d.username = ? AND d.mailbox = ?',
array(
$this->_params['hostspec'],
$this->_params['port'],
$this->_params['username'],
$mailbox
)
);
}
/**
* @param string $mailbox
*
* @return string UID from base table.
*/
protected function _getUid($mailbox)
{
$query = $this->_baseSql($mailbox);
$query[0] = 'SELECT d.messageid ' . $query[0];
try {
return $this->_db->selectValue($query[0], $query[1]);
} catch (Horde_Db_Exception $e) {
return null;
}
}
/**
* @param string $mailbox
*
* @return string UID from base table.
*/
protected function _createUid($mailbox)
{
return $this->_db->insert(
sprintf(
'INSERT INTO %s (hostspec, mailbox, port, username) ' .
'VALUES (?, ?, ?, ?)',
self::BASE_TABLE
),
array(
$this->_params['hostspec'],
$mailbox,
$this->_params['port'],
$this->_params['username']
)
);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Cache/Backend/Hashtable.php 0000664 0001750 0001750 00000026313 13150761653 024170 0 ustar jan jan
* @category Horde
* @copyright 2013-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.17.0
*/
class Horde_Imap_Client_Cache_Backend_Hashtable
extends Horde_Imap_Client_Cache_Backend
{
/** Separator for CID between mailbox and UID. */
const CID_SEPARATOR = '|';
/**
* The working data for the current pageload. All changes take place to
* this data.
*
* @var array
*/
protected $_data = array();
/**
* HashTable object.
*
* @var Horde_HashTable
*/
protected $_hash;
/**
* Mailbox level data.
*
* @var array
*/
protected $_mbox = array();
/**
* Horde_Pack singleton object.
*
* @var Horde_Pack
*/
protected $_pack;
/**
* List of mailbox/UIDs to update.
* Keys are mailboxes. Values are arrays with three possible keys:
*
* - d: UIDs to delete
* - m: Was metadata updated?
* - u: UIDs to update
*
*
* @var array
*/
protected $_update = array();
/**
* Constructor.
*
* @param array $params Configuration parameters:
*
* - REQUIRED parameters:
* - hashtable: (Horde_HashTable) A HashTable object.
*
* - Optional Parameters:
* - lifetime: (integer) The lifetime of the cache data (in seconds).
* DEFAULT: 604800 seconds (1 week) [@since 2.19.0]
*
*/
public function __construct(array $params = array())
{
if (!isset($params['hashtable'])) {
throw new InvalidArgumentException('Missing hashtable parameter.');
}
parent::__construct(array_merge(array(
'lifetime' => 604800
), $params));
}
/**
*/
protected function _initOb()
{
$this->_hash = $this->_params['hashtable'];
$this->_pack = new Horde_Pack();
register_shutdown_function(array($this, 'save'));
}
/**
*/
public function get($mailbox, $uids, $fields, $uidvalid)
{
$ret = array();
if (empty($uids)) {
return $ret;
}
$this->_loadUids($mailbox, $uids, $uidvalid);
if (empty($this->_data[$mailbox])) {
return $ret;
}
if (!empty($fields)) {
$fields = array_flip($fields);
}
$ptr = &$this->_data[$mailbox];
$to_delete = array();
foreach ($uids as $val) {
if (isset($ptr[$val])) {
if (is_string($ptr[$val])) {
try {
$ptr[$val] = $this->_pack->unpack($ptr[$val]);
} catch (Horde_Pack_Exception $e) {
$to_delete[] = $val;
continue;
}
}
$ret[$val] = (empty($fields) || empty($ptr[$val]))
? $ptr[$val]
: array_intersect_key($ptr[$val], $fields);
} else {
$to_delete[] = $val;
}
}
$this->deleteMsgs($mailbox, $to_delete);
return $ret;
}
/**
*/
public function getCachedUids($mailbox, $uidvalid)
{
$this->_loadMailbox($mailbox, $uidvalid);
return $this->_mbox[$mailbox]['u']->ids;
}
/**
*/
public function set($mailbox, $data, $uidvalid)
{
$this->_loadUids($mailbox, array_keys($data), $uidvalid);
$d = &$this->_data[$mailbox];
$to_add = array();
foreach ($data as $k => $v) {
if (isset($d[$k]) && is_string($d[$k])) {
try {
$d[$k] = $this->_pack->unpack($d[$k]);
} catch (Horde_Pack_Exception $e) {
continue;
}
}
$d[$k] = (isset($d[$k]) && is_array($d[$k]))
? array_merge($d[$k], $v)
: $v;
$this->_update[$mailbox]['u'][$k] = true;
unset($this->_update[$mailbox]['d'][$k]);
$to_add[] = $k;
}
if (!empty($to_add)) {
$this->_mbox[$mailbox]['u']->add($to_add);
$this->_update[$mailbox]['m'] = true;
}
}
/**
*/
public function getMetaData($mailbox, $uidvalid, $entries)
{
$this->_loadMailbox($mailbox, $uidvalid);
return empty($entries)
? $this->_mbox[$mailbox]['d']
: array_intersect_key($this->_mbox[$mailbox]['d'], array_flip($entries));
}
/**
*/
public function setMetaData($mailbox, $data)
{
$this->_loadMailbox($mailbox, isset($data['uidvalid']) ? $data['uidvalid'] : null);
$this->_mbox[$mailbox]['d'] = array_merge(
$this->_mbox[$mailbox]['d'],
$data
);
$this->_update[$mailbox]['m'] = true;
}
/**
*/
public function deleteMsgs($mailbox, $uids)
{
if (empty($uids)) {
return;
}
$this->_loadMailbox($mailbox);
foreach ($uids as $val) {
unset(
$this->_data[$mailbox][$val],
$this->_update[$mailbox]['u'][$val]
);
$this->_update[$mailbox]['d'][$val] = true;
}
$this->_mbox[$mailbox]['u']->remove($uids);
$this->_update[$mailbox]['m'] = true;
}
/**
*/
public function deleteMailbox($mailbox)
{
/* Do this action immediately, instead of at shutdown. Makes coding
* simpler. */
$this->_loadMailbox($mailbox);
$this->_hash->delete(array_merge(
array($this->_getCid($mailbox)),
array_values($this->_getMsgCids($mailbox, $this->_mbox[$mailbox]['u']))
));
unset(
$this->_data[$mailbox],
$this->_mbox[$mailbox],
$this->_update[$mailbox]
);
}
/**
*/
public function clear($lifetime)
{
/* Only can clear mailboxes we know about. */
foreach (array_keys($this->_mbox) as $val) {
$this->deleteMailbox($val);
}
$this->_data = $this->_mbox = $this->_update = array();
}
/**
* Updates the cache.
*/
public function save()
{
foreach ($this->_update as $mbox => $val) {
try {
if (!empty($val['u'])) {
$ptr = &$this->_data[$mbox];
foreach ($this->_getMsgCids($mbox, array_keys($val['u'])) as $k2 => $v2) {
try {
$this->_hash->set(
$v2,
$this->_pack->pack($ptr[$k2]),
array('expire' => $this->_params['lifetime'])
);
} catch (Horde_Pack_Exception $e) {
$this->deleteMsgs($mbox, array($v2));
$val['d'][] = $v2;
}
}
}
if (!empty($val['d'])) {
$this->_hash->delete(array_values(
$this->_getMsgCids($mbox, $val['d'])
));
}
if (!empty($val['m'])) {
try {
$this->_hash->set(
$this->_getCid($mbox),
$this->_pack->pack($this->_mbox[$mbox]),
array('expire' => $this->_params['lifetime'])
);
} catch (Horde_Pack_Exception $e) {}
}
} catch (Horde_Exception $e) {
}
}
$this->_update = array();
}
/**
* Loads basic mailbox information.
*
* @param string $mailbox The mailbox to load.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*/
protected function _loadMailbox($mailbox, $uidvalid = null)
{
if (!isset($this->_mbox[$mailbox]) &&
($ob = $this->_hash->get($this->_getCid($mailbox)))) {
try {
$this->_mbox[$mailbox] = $this->_pack->unpack($ob);
} catch (Horde_Pack_Exception $e) {}
}
if (isset($this->_mbox[$mailbox])) {
if (is_null($uidvalid) ||
($uidvalid == $this->_mbox[$mailbox]['d']['uidvalid'])) {
return;
}
$this->deleteMailbox($mailbox);
}
$this->_mbox[$mailbox] = array(
// Metadata storage
// By default includes UIDVALIDITY of mailbox.
'd' => array('uidvalid' => $uidvalid),
// List of UIDs
'u' => new Horde_Imap_Client_Ids()
);
}
/**
* Load UIDs by regenerating from the cache.
*
* @param string $mailbox The mailbox to load.
* @param array $uids The UIDs to load.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*/
protected function _loadUids($mailbox, $uids, $uidvalid = null)
{
if (!isset($this->_data[$mailbox])) {
$this->_data[$mailbox] = array();
}
$this->_loadMailbox($mailbox, $uidvalid);
if (empty($uids)) {
return;
}
$ptr = &$this->_data[$mailbox];
$load = array_flip(
array_diff_key(
$this->_getMsgCids(
$mailbox,
array_unique(array_intersect($this->_mbox[$mailbox]['u']->ids, $uids))
),
$this->_data[$mailbox]
)
);
foreach (array_filter($this->_hash->get(array_keys($load))) as $key => $val) {
$ptr[$load[$key]] = $val;
}
}
/**
* Create the unique ID used to store the mailbox data in the cache.
*
* @param string $mailbox The mailbox to cache.
*
* @return string The cache ID.
*/
protected function _getCid($mailbox)
{
return implode(self::CID_SEPARATOR, array(
'horde_imap_client',
$this->_params['username'],
$mailbox,
$this->_params['hostspec'],
$this->_params['port']
));
}
/**
* Return a list of cache IDs for mailbox/UID pairs.
*
* @param string $mailbox The mailbox to cache.
* @param array $ids The UID list.
*
* @return array List of UIDs => cache IDs.
*/
protected function _getMsgCids($mailbox, $ids)
{
$cid = $this->_getCid($mailbox);
$out = array();
foreach ($ids as $val) {
$out[$val] = $cid . self::CID_SEPARATOR . $val;
}
return $out;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Cache/Backend/Mongo.php 0000664 0001750 0001750 00000027433 13150761653 023360 0 ustar jan jan
* @category Horde
* @copyright 2013-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Cache_Backend_Mongo
extends Horde_Imap_Client_Cache_Backend
implements Horde_Mongo_Collection_Index
{
/** Mongo collection names. */
const BASE = 'horde_imap_client_cache_data';
const MD = 'horde_imap_client_cache_metadata';
const MSG = 'horde_imap_client_cache_message';
/** Mongo field names: BASE collection. */
const BASE_HOSTSPEC = 'hostspec';
const BASE_MAILBOX = 'mailbox';
const BASE_MODIFIED = 'modified';
const BASE_PORT = 'port';
const BASE_UID = 'data';
const BASE_USERNAME = 'username';
/** Mongo field names: MD collection. */
const MD_DATA = 'data';
const MD_FIELD = 'field';
const MD_UID = 'uid';
/** Mongo field names: MSG collection. */
const MSG_DATA = 'data';
const MSG_MSGUID = 'msguid';
const MSG_UID = 'uid';
/**
* The MongoDB object for the cache data.
*
* @var MongoDB
*/
protected $_db;
/**
* The list of indices.
*
* @var array
*/
protected $_indices = array(
self::BASE => array(
'base_index_1' => array(
self::BASE_HOSTSPEC => 1,
self::BASE_MAILBOX => 1,
self::BASE_PORT => 1,
self::BASE_USERNAME => 1,
)
),
self::MSG => array(
'msg_index_1' => array(
self::MSG_MSGUID => 1,
self::MSG_UID => 1
)
)
);
/**
* Constructor.
*
* @param array $params Configuration parameters:
*
* - REQUIRED parameters:
* - mongo_db: (Horde_Mongo_Client) A MongoDB client object.
*
*/
public function __construct(array $params = array())
{
if (!isset($params['mongo_db'])) {
throw new InvalidArgumentException('Missing mongo_db parameter.');
}
parent::__construct($params);
}
/**
*/
protected function _initOb()
{
$this->_db = $this->_params['mongo_db']->selectDB(null);
}
/**
*/
public function get($mailbox, $uids, $fields, $uidvalid)
{
$this->getMetaData($mailbox, $uidvalid, array('uidvalid'));
if (!($uid = $this->_getUid($mailbox))) {
return array();
}
$out = array();
$query = array(
self::MSG_MSGUID => array('$in' => array_map('strval', $uids)),
self::MSG_UID => $uid
);
try {
$cursor = $this->_db->selectCollection(self::MSG)->find(
$query,
array(self::MSG_DATA => true, self::MSG_MSGUID => true)
);
foreach ($cursor as $val) {
try {
$out[$val[self::MSG_MSGUID]] = $this->_value($val[self::MSG_DATA]);
} catch (Exception $e) {}
}
} catch (MongoException $e) {}
return $out;
}
/**
*/
public function getCachedUids($mailbox, $uidvalid)
{
$this->getMetaData($mailbox, $uidvalid, array('uidvalid'));
if (!($uid = $this->_getUid($mailbox))) {
return array();
}
$out = array();
$query = array(
self::MSG_UID => $uid
);
try {
$cursor = $this->_db->selectCollection(self::MSG)->find(
$query, array(self::MSG_MSGUID => true)
);
foreach ($cursor as $val) {
$out[] = $val[self::MSG_MSGUID];
}
} catch (MongoException $e) {}
return $out;
}
/**
*/
public function set($mailbox, $data, $uidvalid)
{
if ($uid = $this->_getUid($mailbox)) {
$res = $this->get($mailbox, array_keys($data), array(), $uidvalid);
} else {
$res = array();
$uid = $this->_createUid($mailbox);
}
$coll = $this->_db->selectCollection(self::MSG);
foreach ($data as $key => $val) {
try {
if (isset($res[$key])) {
$coll->update(array(
self::MSG_MSGUID => strval($key),
self::MSG_UID => $uid
), array(
self::MSG_DATA => $this->_value(array_merge($res[$key], $val)),
self::MSG_MSGUID => strval($key),
self::MSG_UID => $uid
));
} else {
$doc = array(
self::MSG_DATA => $this->_value($val),
self::MSG_MSGUID => strval($key),
self::MSG_UID => $uid
);
$coll->insert($doc);
}
} catch (MongoException $e) {}
}
/* Update modified time. */
try {
$this->_db->selectCollection(self::BASE)->update(
array(self::BASE_UID => $uid),
array(self::BASE_MODIFIED => time())
);
} catch (MongoException $e) {}
/* Update uidvalidity. */
$this->setMetaData($mailbox, array('uidvalid' => $uidvalid));
}
/**
*/
public function getMetaData($mailbox, $uidvalid, $entries)
{
if (!($uid = $this->_getUid($mailbox))) {
return array();
}
$out = array();
$query = array(
self::MD_UID => $uid
);
if (!empty($entries)) {
$entries[] = 'uidvalid';
$query[self::MD_FIELD] = array(
'$in' => array_unique($entries)
);
}
try {
$cursor = $this->_db->selectCollection(self::MD)->find(
$query,
array(self::MD_DATA => true, self::MD_FIELD => true)
);
foreach ($cursor as $val) {
try {
$out[$val[self::MD_FIELD]] = $this->_value($val[self::MD_DATA]);
} catch (Exception $e) {}
}
if (is_null($uidvalid) ||
!isset($out['uidvalid']) ||
($out['uidvalid'] == $uidvalid)) {
return $out;
}
$this->deleteMailbox($mailbox);
} catch (MongoException $e) {}
return array();
}
/**
*/
public function setMetaData($mailbox, $data)
{
if (!($uid = $this->_getUid($mailbox))) {
$uid = $this->_createUid($mailbox);
}
$coll = $this->_db->selectCollection(self::MD);
foreach ($data as $key => $val) {
try {
$coll->update(
array(
self::MD_FIELD => $key,
self::MD_UID => $uid
),
array(
self::MD_DATA => $this->_value($val),
self::MD_FIELD => $key,
self::MD_UID => $uid
),
array('upsert' => true)
);
} catch (MongoException $e) {}
}
}
/**
*/
public function deleteMsgs($mailbox, $uids)
{
if (!empty($uids) && ($uid = $this->_getUid($mailbox))) {
try {
$this->_db->selectCollection(self::MSG)->remove(array(
self::MSG_MSGUID => array(
'$in' => array_map('strval', $uids)
),
self::MSG_UID => $uid
));
} catch (MongoException $e) {}
}
}
/**
*/
public function deleteMailbox($mailbox)
{
if (!($uid = $this->_getUid($mailbox))) {
return;
}
foreach (array(self::BASE, self::MD, self::MSG) as $val) {
try {
$this->_db->selectCollection($val)
->remove(array('uid' => $uid));
} catch (MongoException $e) {}
}
}
/**
*/
public function clear($lifetime)
{
if (is_null($lifetime)) {
foreach (array(self::BASE, self::MD, self::MSG) as $val) {
$this->_db->selectCollection($val)->drop();
}
return;
}
$query = array(
self::BASE_MODIFIED => array('$lt' => (time() - $lifetime))
);
$uids = array();
try {
$cursor = $this->_db->selectCollection(self::BASE)->find($query);
foreach ($cursor as $val) {
$uids[] = strval($val['_id']);
}
} catch (MongoException $e) {}
if (empty($uids)) {
return;
}
foreach (array(self::BASE, self::MD, self::MSG) as $val) {
try {
$this->_db->selectCollection($val)
->remove(array('uid' => array('$in' => $uids)));
} catch (MongoException $e) {}
}
}
/**
* Return the UID for a mailbox/user/server combo.
*
* @param string $mailbox Mailbox name.
*
* @return string UID from base table.
*/
protected function _getUid($mailbox)
{
$query = array(
self::BASE_HOSTSPEC => $this->_params['hostspec'],
self::BASE_MAILBOX => $mailbox,
self::BASE_PORT => $this->_params['port'],
self::BASE_USERNAME => $this->_params['username']
);
try {
if ($result = $this->_db->selectCollection(self::BASE)->findOne($query)) {
return strval($result['_id']);
}
} catch (MongoException $e) {}
return null;
}
/**
* Create and return the UID for a mailbox/user/server combo.
*
* @param string $mailbox Mailbox name.
*
* @return string UID from base table.
*/
protected function _createUid($mailbox)
{
$doc = array(
self::BASE_HOSTSPEC => $this->_params['hostspec'],
self::BASE_MAILBOX => $mailbox,
self::BASE_PORT => $this->_params['port'],
self::BASE_USERNAME => $this->_params['username']
);
$this->_db->selectCollection(self::BASE)->insert($doc);
return $this->_getUid($mailbox);
}
/**
* Convert data from/to storage format.
*
* @param mixed|MongoBinData $data The data object.
*
* @return mixed|MongoBinData The converted data.
*/
protected function _value($data)
{
static $compress;
if (!isset($compress)) {
$compress = new Horde_Compress_Fast();
}
return ($data instanceof MongoBinData)
? @unserialize($compress->decompress($data->bin))
: new MongoBinData(
$compress->compress(serialize($data)), MongoBinData::BYTE_ARRAY
);
}
/* Horde_Mongo_Collection_Index methods. */
/**
*/
public function checkMongoIndices()
{
foreach ($this->_indices as $key => $val) {
if (!$this->_params['mongo_db']->checkIndices($key, $val)) {
return false;
}
}
return true;
}
/**
*/
public function createMongoIndices()
{
foreach ($this->_indices as $key => $val) {
$this->_params['mongo_db']->createIndices($key, $val);
}
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Cache/Backend/Null.php 0000664 0001750 0001750 00000002662 13150761653 023210 0 ustar jan jan
* @category Horde
* @copyright 2013-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Cache_Backend_Null
extends Horde_Imap_Client_Cache_Backend
{
/**
*/
public function get($mailbox, $uids, $fields, $uidvalid)
{
return array();
}
/**
*/
public function getCachedUids($mailbox, $uidvalid)
{
return array();
}
/**
*/
public function set($mailbox, $data, $uidvalid)
{
}
/**
*/
public function getMetaData($mailbox, $uidvalid, $entries)
{
return array(
'uidvalid' => 0
);
}
/**
*/
public function setMetaData($mailbox, $data)
{
}
/**
*/
public function deleteMsgs($mailbox, $uids)
{
}
/**
*/
public function deleteMailbox($mailbox)
{
}
/**
*/
public function clear($lifetime)
{
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Cache/Backend.php 0000664 0001750 0001750 00000011650 13150761653 022273 0 ustar jan jan
* @category Horde
* @copyright 2013-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
abstract class Horde_Imap_Client_Cache_Backend implements Serializable
{
/**
* Configuration paramters.
* Values set by the base Cache object: hostspec, port, username
*
* @var array
*/
protected $_params = array();
/**
* Constructor.
*
* @param array $params Configuration parameters.
*/
public function __construct(array $params = array())
{
$this->setParams($params);
$this->_initOb();
}
/**
* Initialization tasks.
*/
protected function _initOb()
{
}
/**
* Add configuration parameters.
*
* @param array $params Configuration parameters.
*/
public function setParams(array $params = array())
{
$this->_params = array_merge($this->_params, $params);
}
/**
* Get information from the cache for a set of UIDs.
*
* @param string $mailbox An IMAP mailbox string.
* @param array $uids The list of message UIDs to retrieve
* information for.
* @param array $fields An array of fields to retrieve. If empty,
* returns all cached fields.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*
* @return array An array of arrays with the UID of the message as the
* key (if found) and the fields as values (will be
* undefined if not found).
*/
abstract public function get($mailbox, $uids, $fields, $uidvalid);
/**
* Get the list of cached UIDs.
*
* @param string $mailbox An IMAP mailbox string.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*
* @return array The (unsorted) list of cached UIDs.
*/
abstract public function getCachedUids($mailbox, $uidvalid);
/**
* Store data in cache.
*
* @param string $mailbox An IMAP mailbox string.
* @param array $data The list of data to save. The keys are the
* UIDs, the values are an array of information
* to save.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*/
abstract public function set($mailbox, $data, $uidvalid);
/**
* Get metadata information for a mailbox.
*
* @param string $mailbox An IMAP mailbox string.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
* @param array $entries An array of entries to return. If empty,
* returns all metadata.
*
* @return array The requested metadata. Requested entries that do not
* exist will be undefined. The following entries are
* defaults and always present:
* - uidvalid: (integer) The UIDVALIDITY of the mailbox.
*/
abstract public function getMetaData($mailbox, $uidvalid, $entries);
/**
* Set metadata information for a mailbox.
*
* @param string $mailbox An IMAP mailbox string.
* @param array $data The list of data to save. The keys are the
* metadata IDs, the values are the associated
* data. (If present, uidvalidity appears as
* the 'uidvalid' key in $data.)
*/
abstract public function setMetaData($mailbox, $data);
/**
* Delete messages in the cache.
*
* @param string $mailbox An IMAP mailbox string.
* @param array $uids The list of message UIDs to delete.
*/
abstract public function deleteMsgs($mailbox, $uids);
/**
* Delete a mailbox from the cache.
*
* @param string $mailbox The mailbox to delete.
*/
abstract public function deleteMailbox($mailbox);
/**
* Clear the cache.
*
* @param integer $lifetime Only delete entries older than this (in
* seconds). If null, deletes all entries.
*/
abstract public function clear($lifetime);
/* Serializable methods. */
/**
*/
public function serialize()
{
return serialize($this->_params);
}
/**
*/
public function unserialize($data)
{
$this->_params = unserialize($data);
$this->_initOb();
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Capability/Imap.php 0000664 0001750 0001750 00000006774 13150761653 023574 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.24.0
*
* @property-read integer $cmdlength Allowable command length (in octets).
*/
class Horde_Imap_Client_Data_Capability_Imap
extends Horde_Imap_Client_Data_Capability
{
/**
* The list of enabled extensions.
*
* @var array
*/
protected $_enabled = array();
/**
*/
public function __get($name)
{
switch ($name) {
case 'cmdlength':
/* RFC 2683 [3.2.1.5] originally recommended that lines should
* be limited to "approximately 1000 octets". However, servers
* should allow a command line of at least "8000 octets".
* RFC 7162 [4] updates the recommendation to 8192 octets.
* As a compromise, assume all modern IMAP servers handle
* ~2000 octets and, if CONDSTORE/QRESYNC is supported, assume
* they can handle ~8000 octets. (Don't need dependency support
* checks here - the simple presence of CONDSTORE/QRESYNC is
* enough to trigger.) */
return (isset($this->_data['CONDSTORE']) || isset($this->_data['QRESYNC']))
? 8000
: 2000;
}
}
/**
*/
public function query($capability, $parameter = null)
{
if (parent::query($capability, $parameter)) {
return true;
}
switch (Horde_String::upper($capability)) {
case 'CONDSTORE':
case 'ENABLE':
/* RFC 7162 [3.2.3] - QRESYNC implies CONDSTORE and ENABLE. */
return (is_null($parameter) && $this->query('QRESYNC'));
case 'UTF8':
/* RFC 6855 [3] - UTF8=ONLY implies UTF8=ACCEPT. */
return ((Horde_String::upper($parameter) === 'ACCEPT') &&
$this->query('UTF8', 'ONLY'));
}
return false;
}
/**
*/
public function isEnabled($capability = null)
{
return is_null($capability)
? $this->_enabled
: in_array(Horde_String::upper($capability), $this->_enabled);
}
/**
* Set a capability as enabled/disabled.
*
* @param array $capability A capability (+ parameter).
* @param boolean $enable If true, enables the capability.
*/
public function enable($capability, $enable = true)
{
$capability = Horde_String::upper($capability);
$enabled = $this->isEnabled($capability);
if ($enable && !$enabled) {
switch ($capability) {
case 'QRESYNC':
/* RFC 7162 [3.2.3] - Enabling QRESYNC also implies enabling
* of CONDSTORE. */
$this->enable('CONDSTORE');
break;
}
$this->_enabled[] = $capability;
$this->notify();
} elseif (!$enable && $enabled) {
$this->_enabled = array_diff($this->_enabled, array($capability));
$this->notify();
}
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Fetch/Pop3.php 0000664 0001750 0001750 00000001675 13150761653 022472 0 ustar jan jan
* @category Horde
* @copyright 2011-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Fetch_Pop3 extends Horde_Imap_Client_Data_Fetch
{
/**
* Set UID.
*
* @param string $uid The message UID. Unlike IMAP, this UID does not
* have to be an integer.
*/
public function setUid($uid)
{
$this->_data[Horde_Imap_Client::FETCH_UID] = strval($uid);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Astring/Nonascii.php 0000664 0001750 0001750 00000001455 13150761653 025216 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.25.0
*/
class Horde_Imap_Client_Data_Format_Astring_Nonascii
extends Horde_Imap_Client_Data_Format_Astring
implements Horde_Imap_Client_Data_Format_String_Support_Nonascii
{
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Filter/Quote.php 0000664 0001750 0001750 00000003202 13150761653 024356 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Filter_Quote extends php_user_filter
{
/**
* Has the initial quote been prepended?
*
* @var boolean
*/
protected $_prepend;
/**
*/
public function onCreate()
{
$this->_prepend = false;
}
/**
* @see stream_filter_register()
*/
public function filter($in, $out, &$consumed, $closing)
{
if (!$this->_prepend) {
stream_bucket_append($out, stream_bucket_new($this->stream, '"'));
$this->_prepend = true;
}
while ($bucket = stream_bucket_make_writeable($in)) {
$consumed += $bucket->datalen;
$bucket->data = addcslashes($bucket->data, '"\\');
stream_bucket_append($out, $bucket);
}
/* feof() call needed due to:
* http://news.php.net/php.internals/80363 */
if ($closing || feof($this->stream)) {
stream_bucket_append($out, stream_bucket_new($this->stream, '"'));
}
return PSFS_PASS_ON;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Filter/String.php 0000664 0001750 0001750 00000006547 13150761653 024546 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Filter_String extends php_user_filter
{
/**
* Skip status.
*
* @var boolean
*/
protected $_skip = false;
/**
* @see stream_filter_register()
*/
public function onCreate()
{
$this->params->binary = false;
$this->params->literal = false;
$this->params->nonascii = false;
// no_quote_list is used below as a config option
$this->params->quoted = false;
return true;
}
/**
* @see stream_filter_register()
*/
public function filter($in, $out, &$consumed, $closing)
{
$p = $this->params;
while ($bucket = stream_bucket_make_writeable($in)) {
if (!$this->_skip) {
$len = $bucket->datalen;
$str = $bucket->data;
for ($i = 0; $i < $len; ++$i) {
$chr = ord($str[$i]);
switch ($chr) {
case 0: // null
$p->binary = true;
$p->literal = true;
// No need to scan input anymore.
$this->_skip = true;
break 2;
case 10: // LF
case 13: // CR
$p->literal = true;
break;
case 32: // SPACE
case 34: // "
case 40: // (
case 41: // )
case 92: // \
case 123: // {
case 127: // DEL
// These are all invalid ATOM characters.
$p->quoted = true;
break;
case 37: // %
case 42: // *
// These are not quoted if being used as wildcards.
if (empty($p->no_quote_list)) {
$p->quoted = true;
}
break;
default:
if ($chr < 32) {
// CTL characters must be, at a minimum, quoted.
$p->quoted = true;
} elseif ($chr > 127) {
$p->nonascii = true;
// 8-bit chars must be in a literal.
$p->literal = true;
}
break;
}
}
}
$consumed += $bucket->datalen;
stream_bucket_append($out, $bucket);
}
if ($p->literal) {
$p->quoted = false;
}
return PSFS_PASS_ON;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/ListMailbox/Utf8.php 0000664 0001750 0001750 00000002001 13150761653 025105 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_ListMailbox_Utf8
extends Horde_Imap_Client_Data_Format_Mailbox_Utf8
{
/**
*/
protected function _filterParams()
{
$ob = parent::_filterParams();
/* Don't quote % or * characters. */
$ob->no_quote_list = true;
return $ob;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Mailbox/Utf8.php 0000664 0001750 0001750 00000003416 13150761653 024264 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Mailbox_Utf8
extends Horde_Imap_Client_Data_Format_Mailbox
implements Horde_Imap_Client_Data_Format_String_Support_Nonascii
{
/**
*/
protected $_encoding = 'utf8';
/**
*/
public function __construct($data)
{
parent::__construct($data);
/* RFC 3501 allows any US-ASCII character, except null (\0), in
* mailbox data.
* RFC 6855 [3] institutes additional limitations on valid mailbox
* characters, to comply with RFC 5198 [2] (Net-Unicode Definition):
* "MUST NOT contain control characters (U+0000-U+001F and
* U+0080-U+009F), a delete character (U+007F), a line separator
* (U+2028), or a paragraph separator (U+2029)." */
if ($this->quoted() &&
preg_match('/[\x00-\x1f\x7f\x80-\x9f\x{2028}\x{2029}]/u', strval($this))) {
throw new Horde_Imap_Client_Data_Format_Exception(
'Invalid character found in mailbox data.'
);
}
if ($this->literal()) {
$this->forceQuoted();
}
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Nstring/Nonascii.php 0000664 0001750 0001750 00000001455 13150761653 025233 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.25.0
*/
class Horde_Imap_Client_Data_Format_Nstring_Nonascii
extends Horde_Imap_Client_Data_Format_Nstring
implements Horde_Imap_Client_Data_Format_String_Support_Nonascii
{
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/String/Support/Nonascii.php 0000664 0001750 0001750 00000001414 13150761653 026524 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.25.0
*/
interface Horde_Imap_Client_Data_Format_String_Support_Nonascii
{
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/String/Nonascii.php 0000664 0001750 0001750 00000001452 13150761653 025052 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.25.0
*/
class Horde_Imap_Client_Data_Format_String_Nonascii
extends Horde_Imap_Client_Data_Format_String
implements Horde_Imap_Client_Data_Format_String_Support_Nonascii
{
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Astring.php 0000664 0001750 0001750 00000001533 13150761653 023450 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Astring extends Horde_Imap_Client_Data_Format_String
{
/**
*/
public function quoted()
{
return $this->_filter->quoted || !$this->_data->length();
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Atom.php 0000664 0001750 0001750 00000002730 13150761653 022741 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Atom extends Horde_Imap_Client_Data_Format
{
/**
*/
public function escape()
{
return strlen($this->_data)
? parent::escape()
: '""';
}
/**
*/
public function verify()
{
if (strlen($this->_data) !== strlen($this->stripNonAtomCharacters())) {
throw new Horde_Imap_Client_Data_Format_Exception('Illegal character in IMAP atom.');
}
}
/**
* Strip out any characters that are not allowed in an IMAP atom.
*
* @return string The atom data disallowed characters removed.
*/
public function stripNonAtomCharacters()
{
return str_replace(
array('(', ')', '{', ' ', '%', '*', '"', '\\', ']'),
'',
preg_replace('/[^\x20-\x7e]/', '', $this->_data)
);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Date.php 0000664 0001750 0001750 00000002324 13150761653 022715 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Date extends Horde_Imap_Client_Data_Format
{
/**
* Constructor.
*
* @param mixed $data Either a DateTime object, or a date format that
* can be converted to a DateTime object.
*
* @throws Exception
*/
public function __construct($data)
{
if (!($data instanceof DateTime)) {
$data = new Horde_Imap_Client_DateTime($data);
}
parent::__construct($data);
}
/**
*/
public function __toString()
{
return $this->_data->format('j-M-Y');
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/DateTime.php 0000664 0001750 0001750 00000001654 13150761653 023541 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_DateTime extends Horde_Imap_Client_Data_Format_Date
{
/**
*/
public function __toString()
{
return $this->_data->format('j-M-Y H:i:s O');
}
/**
*/
public function escape()
{
return '"' . strval($this) . '"';
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Exception.php 0000664 0001750 0001750 00000001266 13150761653 024002 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Exception extends Horde_Exception_Wrapped
{
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/List.php 0000664 0001750 0001750 00000005673 13150761653 022765 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_List extends Horde_Imap_Client_Data_Format implements Countable, IteratorAggregate
{
/**
* @see add()
*/
public function __construct($data = null)
{
parent::__construct(array());
if (!is_null($data)) {
$this->add($data);
}
}
/**
* Add an element to the list.
*
* @param mixed $data The data element(s) to add. Either a
* Horde_Imap_Client_Data_Format object, a string
* value that will be treated as an IMAP atom, or
* an array (or iterable object) of objects to add.
* @param boolean $merge Merge the contents of any container objects,
* instead of adding the objects themselves?
*
* @return Horde_Imap_Client_Data_Format_List This object to allow for
* chainable calls (since
* 2.10.0).
*/
public function add($data, $merge = false)
{
if (is_array($data) || ($merge && ($data instanceof Traversable))) {
foreach ($data as $val) {
$this->add($val);
}
} elseif (is_object($data)) {
$this->_data[] = $data;
} elseif (!is_null($data)) {
$this->_data[] = new Horde_Imap_Client_Data_Format_Atom($data);
}
return $this;
}
/**
*/
public function __toString()
{
$out = '';
foreach ($this as $val) {
if ($val instanceof $this) {
$out .= '(' . $val->escape() . ') ';
} elseif (($val instanceof Horde_Imap_Client_Data_Format_String) &&
$val->literal()) {
/* ERROR: Requires literal output. */
return '';
} else {
$out .= $val->escape() . ' ';
}
}
return rtrim($out);
}
/* Countable methods. */
/**
*/
public function count()
{
return count($this->_data);
}
/* IteratorAggregate method. */
/**
* Iterator loops through the data elements contained in this list.
*/
public function getIterator()
{
return new ArrayIterator($this->_data);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/ListMailbox.php 0000664 0001750 0001750 00000001661 13150761653 024272 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_ListMailbox
extends Horde_Imap_Client_Data_Format_Mailbox
{
/**
*/
protected function _filterParams()
{
$ob = parent::_filterParams();
/* Don't quote % or * characters. */
$ob->no_quote_list = true;
return $ob;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Mailbox.php 0000664 0001750 0001750 00000004354 13150761653 023440 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Mailbox
extends Horde_Imap_Client_Data_Format_Astring
{
/**
* Mailbox encoding.
*
* @var string
*/
protected $_encoding = 'utf7imap';
/**
* Mailbox object.
*
* @var Horde_Imap_Client_Mailbox
*/
protected $_mailbox;
/**
* @param mixed $data Either a mailbox object or a UTF-8 mailbox name.
*/
public function __construct($data)
{
$this->_mailbox = Horde_Imap_Client_Mailbox::get($data);
parent::__construct($this->_mailbox->{$this->_encoding});
}
/**
*/
public function __toString()
{
return strval($this->_mailbox);
}
/**
*/
public function getData()
{
return $this->_mailbox;
}
/**
* @throws Horde_Imap_Client_Exception
*/
public function binary()
{
if (parent::binary()) {
// Mailbox data can NEVER be sent as binary.
/* @todo: Disable until Horde_Imap_Client 3.0 */
// throw new Horde_Imap_Client_Exception(
// 'Client error: can not send mailbox to IMAP server as binary data.'
// );
// Temporary fix: send a blank mailbox string.
$this->_mailbox = Horde_Imap_Client_Mailbox::get('');
}
return false;
}
/**
*/
public function length()
{
return strlen($this->_mailbox->{$this->_encoding});
}
/**
*/
public function getStream()
{
$stream = new Horde_Stream_Temp();
$stream->add($this->_mailbox->{$this->_encoding});
return $stream;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Nil.php 0000664 0001750 0001750 00000001726 13150761653 022567 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Nil extends Horde_Imap_Client_Data_Format
{
/**
*/
public function __construct($data = null)
{
// Don't store any data in object.
}
/**
*/
public function __toString()
{
return '';
}
/**
*/
public function escape()
{
return 'NIL';
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Nstring.php 0000664 0001750 0001750 00000003717 13150761653 023473 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Nstring extends Horde_Imap_Client_Data_Format_String
{
/**
*/
public function __construct($data = null)
{
/* Data can be null (NIL) here. */
if (is_null($data)) {
$this->_data = null;
} else {
parent::__construct($data);
}
}
/**
*/
public function __toString()
{
return is_null($this->_data)
? ''
: parent::__toString();
}
/**
*/
public function escape()
{
return is_null($this->_data)
? 'NIL'
: parent::escape();
}
public function escapeStream()
{
if (is_null($this->_data)) {
$stream = new Horde_Stream_Temp();
$stream->add('NIL', true);
return $stream->stream;
}
return parent::escapeStream();
}
/**
*/
public function quoted()
{
return is_null($this->_data)
? false
: parent::quoted();
}
/**
*/
public function length()
{
return is_null($this->_data)
? 0
: parent::length();
}
/**
*/
public function getStream()
{
return is_null($this->_data)
? new Horde_Stream_Temp()
: parent::getStream();
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/Number.php 0000664 0001750 0001750 00000002001 13150761653 023260 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_Number extends Horde_Imap_Client_Data_Format
{
/**
*/
public function __toString()
{
return strval(intval($this->_data));
}
/**
*/
public function verify()
{
if (!is_numeric($this->_data)) {
throw new Horde_Imap_Client_Data_Format_Exception('Illegal character in IMAP number.');
}
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Format/String.php 0000664 0001750 0001750 00000013343 13150761653 023311 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Format_String
extends Horde_Imap_Client_Data_Format
{
/**
* String filter parameters.
*
* @var string
*/
protected $_filter;
/**
* @param array $opts Additional options:
* - eol: (boolean) If true, normalize EOLs in input. @since 2.2.0
* - skipscan: (boolean) If true, don't scan input for
* binary/literal/quoted data. @since 2.2.0
*
* @throws Horde_Imap_Client_Data_Format_Exception
*/
public function __construct($data, array $opts = array())
{
/* String data is stored in a stream. */
$this->_data = new Horde_Stream_Temp();
if (empty($opts['skipscan'])) {
$this->_filter = $this->_filterParams();
stream_filter_register('horde_imap_client_string', 'Horde_Imap_Client_Data_Format_Filter_String');
$res = stream_filter_append($this->_data->stream, 'horde_imap_client_string', STREAM_FILTER_WRITE, $this->_filter);
} else {
$res = null;
}
if (empty($opts['eol'])) {
$res2 = null;
} else {
stream_filter_register('horde_eol', 'Horde_Stream_Filter_Eol');
$res2 = stream_filter_append($this->_data->stream, 'horde_eol', STREAM_FILTER_WRITE);
}
$this->_data->add($data);
if (!is_null($res)) {
stream_filter_remove($res);
}
if (!is_null($res2)) {
stream_filter_remove($res2);
}
if (isset($this->_filter) &&
$this->_filter->nonascii &&
!($this instanceof Horde_Imap_Client_Data_Format_String_Support_Nonascii)) {
throw new Horde_Imap_Client_Data_Format_Exception(
'String contains non-ASCII characters.'
);
}
}
/**
* Return the base string filter parameters.
*
* @return object Filter parameters.
*/
protected function _filterParams()
{
return new stdClass;
}
/**
*/
public function __toString()
{
return $this->_data->getString(0);
}
/**
*/
public function escape()
{
if ($this->literal()) {
throw new Horde_Imap_Client_Data_Format_Exception('String requires literal to output.');
}
return $this->quoted()
? stream_get_contents($this->escapeStream())
: $this->_data->getString(0);
}
/**
* Return the escaped string as a stream.
*
* @return resource The IMAP escaped stream.
*/
public function escapeStream()
{
if ($this->literal()) {
throw new Horde_Imap_Client_Data_Format_Exception('String requires literal to output.');
}
rewind($this->_data->stream);
$stream = new Horde_Stream_Temp();
$stream->add($this->_data, true);
stream_filter_register('horde_imap_client_string_quote', 'Horde_Imap_Client_Data_Format_Filter_Quote');
stream_filter_append($stream->stream, 'horde_imap_client_string_quote', STREAM_FILTER_READ);
return $stream->stream;
}
/**
* Does this data item require quoted string output?
*
* @return boolean True if quoted output is required.
*/
public function quoted()
{
/* IMAP strings MUST be quoted if they are not a literal. */
return (!isset($this->_filter) || !$this->_filter->literal);
}
/**
* Force item to be output quoted.
*/
public function forceQuoted()
{
$this->_filter = $this->_filterParams();
$this->_filter->binary = false;
$this->_filter->literal = false;
$this->_filter->quoted = true;
}
/**
* Does this data item require literal string output?
*
* @return boolean True if literal output is required.
*/
public function literal()
{
return (isset($this->_filter) && $this->_filter->literal);
}
/**
* Force item to be output as a literal.
*/
public function forceLiteral()
{
$this->_filter = $this->_filterParams();
// Keep binary status, if set
$this->_filter->literal = true;
$this->_filter->quoted = false;
}
/**
* If literal output, is the data binary?
*
* @return boolean True if the literal output is binary.
*/
public function binary()
{
return (isset($this->_filter) && !empty($this->_filter->binary));
}
/**
* Force item to be output as a binary literal.
*/
public function forceBinary()
{
$this->_filter = $this->_filterParams();
$this->_filter->binary = true;
$this->_filter->literal = true;
$this->_filter->quoted = false;
}
/**
* Return the length of the data.
*
* @since 2.2.0
*
* @return integer Data length.
*/
public function length()
{
return $this->_data->length();
}
/**
* Return the contents of the string as a stream object.
*
* @since 2.3.0
*
* @return Horde_Stream The stream object.
*/
public function getStream()
{
return $this->_data;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/SearchCharset/Utf8.php 0000664 0001750 0001750 00000002517 13150761653 024161 0 ustar jan jan
* @category Horde
* @copyright 2014-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.24.0
*/
class Horde_Imap_Client_Data_SearchCharset_Utf8
extends Horde_Imap_Client_Data_SearchCharset
{
/**
* Charset data.
*
* @var array
*/
protected $_charsets = array(
'US-ASCII' => true,
'UTF-8' => true
);
/**
*/
public function query($charset, $cached = false)
{
return isset($this->_charsets[Horde_String::upper($charset)]);
}
/**
*/
public function setValid($charset, $valid = true)
{
}
/* Serializable methods. */
/**
*/
public function serialize()
{
return '';
}
/**
*/
public function unserialize($data)
{
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/Acl.php 0000664 0001750 0001750 00000010065 13150761653 021310 0 ustar jan jan
* @category Horde
* @copyright 2011-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_Acl extends Horde_Imap_Client_Data_AclCommon implements ArrayAccess, IteratorAggregate, Serializable
{
/**
* ACL rights.
*
* @var array
*/
protected $_rights;
/**
* Constructor.
*
* @param string $rights The rights (see RFC 4314 [2.1]).
*/
public function __construct($rights = '')
{
$this->_rights = str_split($rights);
$this->_normalize();
}
/**
* String representation of the ACL.
*
* @return string String representation (RFC 4314 compliant).
*/
public function __toString()
{
return implode('', $this->_rights);
}
/**
* Computes the difference to another rights string.
* Virtual rights are ignored.
*
* @param string $rights The rights to compute against.
*
* @return array Two element array: added and removed.
*/
public function diff($rights)
{
$rlist = array_diff(str_split($rights), array_keys($this->_virtual));
return array(
'added' => implode('', array_diff($rlist, $this->_rights)),
'removed' => implode('', array_diff($this->_rights, $rlist))
);
}
/**
* Normalize virtual rights (see RFC 4314 [2.1.1]).
*/
protected function _normalize()
{
/* Clients conforming to RFC 4314 MUST ignore the virtual ACL_CREATE
* and ACL_DELETE rights. See RFC 4314 [2.1]. However, we still need
* to handle these rights when dealing with RFC 2086 servers since
* we are abstracting out use of ACL_CREATE/ACL_DELETE to their
* component RFC 4314 rights. */
foreach ($this->_virtual as $key => $val) {
foreach ($val as $right) {
if ($this[$right]) {
foreach (array_keys($this->_virtual) as $virtual) {
unset($this[$virtual]);
}
return;
}
}
}
foreach ($this->_virtual as $key => $val) {
if ($this[$key]) {
unset($this[$key]);
$this->_rights = array_unique(array_merge($this->_rights, $val));
}
}
}
/* ArrayAccess methods. */
/**
*/
public function offsetExists($offset)
{
return $this[$offset];
}
/**
*/
public function offsetGet($offset)
{
return in_array($offset, $this->_rights);
}
/**
*/
public function offsetSet($offset, $value)
{
if ($value) {
if (!$this[$offset]) {
$this->_rights[] = $offset;
$this->_normalize();
}
} elseif ($this[$offset]) {
if (isset($this->_virtual[$offset])) {
foreach ($this->_virtual[$offset] as $val) {
unset($this[$val]);
}
}
unset($this[$offset]);
}
}
/**
*/
public function offsetUnset($offset)
{
$this->_rights = array_values(array_diff($this->_rights, array($offset)));
}
/* IteratorAggregate method. */
public function getIterator()
{
return new ArrayIterator($this->_rights);
}
/* Serializable methods. */
/**
*/
public function serialize()
{
return json_encode($this->_rights);
}
/**
*/
public function unserialize($data)
{
$this->_rights = json_decode($data);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/AclCommon.php 0000664 0001750 0001750 00000004014 13150761653 022456 0 ustar jan jan
* @category Horde
* @copyright 2011-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_AclCommon
{
/** Constants for getString(). */
const RFC_2086 = 1;
const RFC_4314 = 2;
/**
* List of virtual rights (RFC 4314 [2.1.1]).
*
* @var array
*/
protected $_virtual = array(
Horde_Imap_Client::ACL_CREATE => array(
Horde_Imap_Client::ACL_CREATEMBOX,
Horde_Imap_Client::ACL_DELETEMBOX
),
Horde_Imap_Client::ACL_DELETE => array(
Horde_Imap_Client::ACL_DELETEMSGS,
// Don't put this first - we do checks on the existence of the
// first element in this array to determine the RFC type, and this
// is duplicate of right contained in ACL_CREATE.
Horde_Imap_Client::ACL_DELETEMBOX,
Horde_Imap_Client::ACL_EXPUNGE
)
);
/**
* Returns the raw string to use in IMAP server calls.
*
* @param integer $type The RFC type to use (RFC_* constant).
*
* @return string The string representation of the ACL.
*/
public function getString($type = self::RFC_4314)
{
$acl = strval($this);
if ($type == self::RFC_2086) {
foreach ($this->_virtual as $key => $val) {
$acl = str_replace($val, '', $acl, $count);
if ($count) {
$acl .= $key;
}
}
}
return $acl;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/AclNegative.php 0000664 0001750 0001750 00000001303 13150761653 022766 0 ustar jan jan
* @category Horde
* @copyright 2011-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_AclNegative extends Horde_Imap_Client_Data_Acl
{
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/AclRights.php 0000664 0001750 0001750 00000011614 13150761653 022472 0 ustar jan jan
* @category Horde
* @copyright 2011-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Data_AclRights extends Horde_Imap_Client_Data_AclCommon implements ArrayAccess, Iterator, Serializable
{
/**
* ACL optional rights.
*
* @var array
*/
protected $_optional = array();
/**
* ACL required rights.
*
* @var array
*/
protected $_required = array();
/**
* Constructor.
*
* @param array $required The required rights (see RFC 4314 [2.1]).
* @param array $optional The optional rights (see RFC 4314 [2.1]).
*/
public function __construct(array $required = array(),
array $optional = array())
{
$this->_required = $required;
foreach ($optional as $val) {
foreach (str_split($val) as $right) {
$this->_optional[$right] = $val;
}
}
$this->_normalize();
}
/**
* String representation of the ACL.
*
* @return string String representation (RFC 4314 compliant).
*
*/
public function __toString()
{
return implode('', array_keys(array_flip(array_merge(array_values($this->_required), array_keys($this->_optional)))));
}
/**
* Normalize virtual rights (see RFC 4314 [2.1.1]).
*/
protected function _normalize()
{
/* Clients conforming to RFC 4314 MUST ignore the virtual ACL_CREATE
* and ACL_DELETE rights. See RFC 4314 [2.1]. However, we still need
* to handle these rights when dealing with RFC 2086 servers since
* we are abstracting out use of ACL_CREATE/ACL_DELETE to their
* component RFC 4314 rights. */
foreach ($this->_virtual as $key => $val) {
if (isset($this->_optional[$key])) {
unset($this->_optional[$key]);
foreach ($val as $val2) {
$this->_optional[$val2] = implode('', $val);
}
} elseif (($pos = array_search($key, $this->_required)) !== false) {
unset($this->_required[$pos]);
$this->_required = array_unique(array_merge($this->_required, $val));
}
}
}
/* ArrayAccess methods. */
/**
*/
public function offsetExists($offset)
{
return (bool)$this[$offset];
}
/**
*/
public function offsetGet($offset)
{
if (isset($this->_optional[$offset])) {
return $this->_optional[$offset];
}
$pos = array_search($offset, $this->_required);
return ($pos === false)
? null
: $this->_required[$pos];
}
/**
*/
public function offsetSet($offset, $value)
{
$this->_optional[$offset] = $value;
$this->_normalize();
}
/**
*/
public function offsetUnset($offset)
{
unset($this->_optional[$offset]);
$this->_required = array_values(array_diff($this->_required, array($offset)));
if (isset($this->_virtual[$offset])) {
foreach ($this->_virtual[$offset] as $val) {
unset($this[$val]);
}
}
}
/* Iterator methods. */
/**
*/
public function current()
{
$val = current($this->_required);
return is_null($val)
? current($this->_optional)
: $val;
}
/**
*/
public function key()
{
$key = key($this->_required);
return is_null($key)
? key($this->_optional)
: $key;
}
/**
*/
public function next()
{
if (key($this->_required) === null) {
next($this->_optional);
} else {
next($this->_required);
}
}
/**
*/
public function rewind()
{
reset($this->_required);
reset($this->_optional);
}
/**
*/
public function valid()
{
return ((key($this->_required) !== null) ||
(key($this->_optional) !== null));
}
/* Serializable methods. */
/**
*/
public function serialize()
{
return json_encode(array(
$this->_required,
$this->_optional
));
}
/**
*/
public function unserialize($data)
{
list($this->_required, $this->_optional) = json_decode($data);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Data/BaseSubject.php 0000664 0001750 0001750 00000014220 13150761653 023000 0 ustar jan jan
*
* See the enclosed file COPYING for license information (LGPL). If you
* did not receive this file, see http://www.horde.org/licenses/lgpl21.
*
* @category Horde
* @copyright 2002-2008 Timo Sirainen
* @copyright 2008-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
/**
* Determines the "base subject" of a string (RFC 5256 [2.1]).
*
* @author Timo Sirainen * - STD 53/RFC 1939: POP3 specification * - RFC 2195: CRAM-MD5 authentication * - RFC 2449: POP3 extension mechanism * - RFC 2595/4616: PLAIN authentication * - RFC 2831: DIGEST-MD5 SASL Authentication (obsoleted by RFC 6331) * - RFC 3206: AUTH/SYS response codes * - RFC 4616: AUTH=PLAIN * - RFC 5034: POP3 SASL * - RFC 5802: AUTH=SCRAM-SHA-1 * - RFC 6856: UTF8, LANG ** * @author Richard Heyes
* - debug: (string) When debugging, send this string instead of the
* actual command/data sent.
* DEFAULT: Raw data output to debug stream.
* - multiline: (mixed) 'array', 'none', or 'stream'.
*
*
* @return array See _getResponse().
*
* @throws Horde_Imap_Client_Exception
*/
protected function _sendLine($cmd, $options = array())
{
if (!empty($options['debug'])) {
$this->_debug->client($options['debug']);
}
if ($this->_debug->debug) {
$timer = new Horde_Support_Timer();
$timer->push();
}
try {
$this->_connection->write($cmd, empty($options['debug']));
} catch (Horde_Imap_Client_Exception $e) {
throw $e;
}
$resp = $this->_getResponse(
empty($options['multiline']) ? false : $options['multiline']
);
if ($this->_debug->debug) {
$this->_debug->info(sprintf(
'Command took %s seconds.',
round($timer->pop(), 4)
));
}
return $resp;
}
/**
* Gets a line from the stream and parses it.
*
* @param mixed $multiline 'array', 'none', 'stream', or null.
*
* @return array An array with the following keys:
* - data: (mixed) Stream, array, or null.
* - resp: (string) The server response text.
*
* @throws Horde_Imap_Client_Exception
*/
protected function _getResponse($multiline = false)
{
$ob = array('resp' => '');
$read = explode(' ', rtrim($this->_connection->read(), "\r\n"), 2);
if (!in_array($read[0], array('+OK', '-ERR', '+'))) {
$this->_debug->info('ERROR: IMAP read/timeout error.');
throw new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("Error when communicating with the mail server."),
Horde_Imap_Client_Exception::SERVER_READERROR
);
}
$respcode = null;
if (isset($read[1]) &&
isset($this->_init['capability']) &&
$this->_capability('RESP-CODES')) {
$respcode = $this->_parseResponseCode($read[1]);
}
switch ($read[0]) {
case '+OK':
case '+':
if ($respcode) {
$ob['resp'] = $respcode->text;
} elseif (isset($read[1])) {
$ob['resp'] = $read[1];
}
break;
case '-ERR':
$errcode = 0;
if ($respcode) {
$errtext = $respcode->text;
if (isset($respcode->code)) {
switch ($respcode->code) {
// RFC 2449 [8.1.1]
case 'IN-USE':
// RFC 2449 [8.1.2]
case 'LOGIN-DELAY':
$errcode = Horde_Imap_Client_Exception::LOGIN_UNAVAILABLE;
break;
// RFC 3206 [4]
case 'SYS/TEMP':
$errcode = Horde_Imap_Client_Exception::POP3_TEMP_ERROR;
break;
// RFC 3206 [4]
case 'SYS/PERM':
$errcode = Horde_Imap_Client_Exception::POP3_PERM_ERROR;
break;
// RFC 3206 [5]
case 'AUTH':
$errcode = Horde_Imap_Client_Exception::LOGIN_AUTHENTICATIONFAILED;
break;
// RFC 6856 [5]
case 'UTF8':
/* This code can only be issued if we (as client) are
* broken, so no need to handle since we should never
* be broken. */
break;
}
}
} elseif (isset($read[1])) {
$errtext = $read[1];
} else {
$errtext = '[No error message provided by server]';
}
$e = new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("POP3 error reported by server."),
$errcode
);
$e->details = $errtext;
throw $e;
}
switch ($multiline) {
case 'array':
$ob['data'] = array();
break;
case 'none':
$ob['data'] = null;
break;
case 'stream':
$ob['data'] = fopen('php://temp', 'r+');
break;
default:
return $ob;
}
do {
$orig_read = $this->_connection->read();
$read = rtrim($orig_read, "\r\n");
if ($read === '.') {
break;
} elseif (substr($read, 0, 2) === '..') {
$read = substr($read, 1);
}
if (is_array($ob['data'])) {
$ob['data'][] = $read;
} elseif (!is_null($ob['data'])) {
fwrite($ob['data'], $orig_read);
}
} while (true);
return $ob;
}
/**
* Returns a list of sequence IDs.
*
* @param Horde_Imap_Client_Ids $ids The ID list.
*
* @return array A list of sequence IDs.
*/
protected function _getSeqIds(Horde_Imap_Client_Ids $ids)
{
if (!count($ids)) {
$status = $this->status($this->_selected, Horde_Imap_Client::STATUS_MESSAGES);
return range(1, $status['messages']);
} elseif ($ids->sequence) {
return $ids->ids;
}
return array_keys(array_intersect($this->_pop3Cache('uidl'), $ids->ids));
}
/**
* Parses response text for response codes (RFC 2449 [8]).
*
* @param string $text The response text.
*
* @return object An object with the following properties:
* - code: (string) The response code, if it exists.
* - data: (string) The response code data, if it exists.
* - text: (string) The human-readable response text.
*/
protected function _parseResponseCode($text)
{
$ret = new stdClass;
$text = trim($text);
if ($text[0] === '[') {
$pos = strpos($text, ' ', 2);
$end_pos = strpos($text, ']', 2);
if ($pos > $end_pos) {
$ret->code = Horde_String::upper(substr($text, 1, $end_pos - 1));
} else {
$ret->code = Horde_String::upper(substr($text, 1, $pos - 1));
$ret->data = substr($text, $pos + 1, $end_pos - $pos - 1);
}
$ret->text = trim(substr($text, $end_pos + 1));
} else {
$ret->text = $text;
}
return $ret;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Url/Imap/Relative.php 0000664 0001750 0001750 00000002165 13150761653 023145 0 ustar jan jan
* @category Horde
* @copyright 2008-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.25.0
*/
class Horde_Imap_Client_Url_Imap_Relative
extends Horde_Imap_Client_Url_Imap
{
/**
* Create a relative IMAP URL (RFC 5092/5593).
*
* @return string A URL string.
*/
public function __toString()
{
if ($out = $this->_toImapString()) {
if (substr($out, 0, 2) === '/;') {
$out = substr($out, 1);
} elseif ($out[0] !== ';') {
$out = '/' . $out;
}
}
return $out;
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Url/Base.php 0000664 0001750 0001750 00000007041 13150761653 021354 0 ustar jan jan
* @category Horde
* @copyright 2008-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
* @since 2.25.0
*
* @property string $auth The authentication method.
* @property string $host The server.
* @property integer $port The port.
* @property string $username The username.
*/
abstract class Horde_Imap_Client_Url_Base implements Serializable
{
/**
* The authentication method to use.
*
* @var string
*/
protected $_auth = null;
/**
* The server name.
*
* @var string
*/
protected $_host = null;
/**
* The port.
*
* @var integer
*/
protected $_port = null;
/**
* The username.
*
* @var string
*/
protected $_username = null;
/**
* Constructor.
*
* @param string $url A URL string.
*/
public function __construct($url = null)
{
if (!is_null($url)) {
$this->_parse($url);
}
}
/**
*/
public function __get($name)
{
switch ($name) {
case 'auth':
case 'host':
case 'port':
case 'username':
return $this->{'_' . $name};
}
}
/**
*/
public function __set($name, $value)
{
switch ($name) {
case 'auth':
case 'host':
case 'port':
case 'username':
$this->{'_' . $name} = $value;
break;
}
}
/**
* Create a POP3 (RFC 2384) or IMAP (RFC 5092/5593) URL.
*
* @return string A URL string.
*/
public function __toString()
{
$url = '';
if (!is_null($this->username)) {
$url .= $this->username;
if (!is_null($this->auth)) {
$url .= ';AUTH=' . $this->auth;
}
$url .= '@';
}
$url .= $this->host;
return $url;
}
/**
*/
protected function _parse($url)
{
$data = parse_url(trim($url));
if (isset($data['scheme'])) {
if (isset($data['host'])) {
$this->host = $data['host'];
}
if (isset($data['port'])) {
$this->port = $data['port'];
}
}
/* Check for username/auth information. */
if (isset($data['user'])) {
if (($pos = stripos($data['user'], ';AUTH=')) !== false) {
$auth = substr($data['user'], $pos + 6);
if ($auth !== '*') {
$this->auth = $auth;
}
$data['user'] = substr($data['user'], 0, $pos);
}
if (strlen($data['user'])) {
$this->username = $data['user'];
}
}
$this->_parseUrl($data);
}
/**
*/
abstract protected function _parseUrl(array $data);
/* Serializable methods. */
/**
*/
public function serialize()
{
return strval($this);
}
/**
*/
public function unserialize($data)
{
$this->_parse($data);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Url/Imap.php 0000664 0001750 0001750 00000012563 13150761653 021375 0 ustar jan jan [/]
* - imap://
* - cache: (array) If set, caches data from fetch(), search(), and
* thread() calls. Requires the horde/Cache package to be
* installed. The array can contain the following keys (see
* Horde_Imap_Client_Cache for default values):
* - backend: [REQUIRED (or cacheob)] (Horde_Imap_Client_Cache_Backend)
* Backend cache driver [@since 2.9.0].
* - fetch_ignore: (array) A list of mailboxes to ignore when storing
* fetch data.
* - fields: (array) The fetch criteria to cache. If not defined, all
* cacheable data is cached. The following is a list of
* criteria that can be cached:
* - Horde_Imap_Client::FETCH_ENVELOPE
* - Horde_Imap_Client::FETCH_FLAGS
* Only if server supports CONDSTORE extension
* - Horde_Imap_Client::FETCH_HEADERS
* Only for queries that specifically request caching
* - Horde_Imap_Client::FETCH_IMAPDATE
* - Horde_Imap_Client::FETCH_SIZE
* - Horde_Imap_Client::FETCH_STRUCTURE
* - capability_ignore: (array) A list of IMAP capabilites to ignore, even
* if they are supported on the server.
* DEFAULT: No supported capabilities are ignored.
* - comparator: (string) The search comparator to use instead of the
* default server comparator. See setComparator() for
* format.
* DEFAULT: Use the server default
* - context: (array) Any context parameters passed to
* stream_create_context(). @since 2.27.0
* - debug: (string) If set, will output debug information to the stream
* provided. The value can be any PHP supported wrapper that can
* be opened via PHP's fopen() function.
* DEFAULT: No debug output
* - hostspec: (string) The hostname or IP address of the server.
* DEFAULT: 'localhost'
* - id: (array) Send ID information to the server (only if server
* supports the ID extension). An array with the keys as the fields
* to send and the values being the associated values. See RFC 2971
* [3.3] for a list of standard field values.
* DEFAULT: No info sent to server
* - lang: (array) A list of languages (in priority order) to be used to
* display human readable messages.
* DEFAULT: Messages output in IMAP server default language
* - password: (mixed) The user password. Either a string or a
* Horde_Imap_Client_Base_Password object [@since 2.14.0].
* - port: (integer) The server port to which we will connect.
* DEFAULT: 143 (imap or imap w/TLS) or 993 (imaps)
* - secure: (string) Use SSL or TLS to connect. Values:
* - false (No encryption)
* - 'ssl' (Auto-detect SSL version)
* - 'sslv2' (Force SSL version 3)
* - 'sslv3' (Force SSL version 2)
* - 'tls' (TLS; started via protocol-level negotation over
* unencrypted channel; RECOMMENDED way of initiating secure
* connection)
* - 'tlsv1' (TLS direct version 1.x connection to server) [@since
* 2.16.0]
* - true (TLS if available/necessary) [@since 2.15.0]
* DEFAULT: false
* - timeout: (integer) Connection timeout, in seconds.
* DEFAULT: 30 seconds
* - username: (string) [REQUIRED] The username.
*
*/
public function __construct(array $params = array())
{
if (!isset($params['username'])) {
throw new InvalidArgumentException('Horde_Imap_Client requires a username.');
}
$this->_setInit();
// Default values.
$params = array_merge(array(
'context' => array(),
'hostspec' => 'localhost',
'secure' => false,
'timeout' => 30
), array_filter($params));
if (!isset($params['port']) && strpos($params['hostspec'], 'unix://') !== 0) {
$params['port'] = (!empty($params['secure']) && in_array($params['secure'], array('ssl', 'sslv2', 'sslv3'), true))
? $this->_defaultPorts[1]
: $this->_defaultPorts[0];
}
if (empty($params['cache'])) {
$params['cache'] = array('fields' => array());
} elseif (empty($params['cache']['fields'])) {
$params['cache']['fields'] = $this->cacheFields;
} else {
$params['cache']['fields'] = array_flip($params['cache']['fields']);
}
if (empty($params['cache']['fetch_ignore'])) {
$params['cache']['fetch_ignore'] = array();
}
$this->_params = $params;
if (isset($params['password'])) {
$this->setParam('password', $params['password']);
}
$this->changed = true;
$this->_initOb();
}
/**
* Get encryption key.
*
* @deprecated Pass callable into 'password' parameter instead.
*
* @return string The encryption key.
*/
protected function _getEncryptKey()
{
if (is_callable($ekey = $this->getParam('encryptKey'))) {
return call_user_func($ekey);
}
throw new InvalidArgumentException('encryptKey parameter is not a valid callback.');
}
/**
* Do initialization tasks.
*/
protected function _initOb()
{
register_shutdown_function(array($this, 'shutdown'));
$this->_alerts = new Horde_Imap_Client_Base_Alerts();
// @todo: Remove (BC)
$this->_alerts->attach($this);
$this->_debug = ($debug = $this->getParam('debug'))
? new Horde_Imap_Client_Base_Debug($debug)
: new Horde_Support_Stub();
// @todo: Remove (BC purposes)
if (isset($this->_init['capability']) &&
!is_object($this->_init['capability'])) {
$this->_setInit('capability');
}
foreach (array('capability', 'search_charset') as $val) {
if (isset($this->_init[$val])) {
$this->_init[$val]->attach($this);
}
}
}
/**
* Shutdown actions.
*/
public function shutdown()
{
try {
$this->logout();
} catch (Horde_Imap_Client_Exception $e) {
}
}
/**
* This object can not be cloned.
*/
public function __clone()
{
throw new LogicException('Object cannot be cloned.');
}
/**
*/
public function update(SplSubject $subject)
{
if (($subject instanceof Horde_Imap_Client_Data_Capability) ||
($subject instanceof Horde_Imap_Client_Data_SearchCharset)) {
$this->changed = true;
}
/* @todo: BC - remove */
if ($subject instanceof Horde_Imap_Client_Base_Alerts) {
$this->_temp['alerts'][] = $subject->getLast()->alert;
}
}
/**
*/
public function serialize()
{
return serialize(array(
'i' => $this->_init,
'p' => $this->_params,
'v' => self::VERSION
));
}
/**
*/
public function unserialize($data)
{
$data = @unserialize($data);
if (!is_array($data) ||
!isset($data['v']) ||
($data['v'] != self::VERSION)) {
throw new Exception('Cache version change');
}
$this->_init = $data['i'];
$this->_params = $data['p'];
$this->_initOb();
}
/**
*/
public function __get($name)
{
switch ($name) {
case 'alerts_ob':
return $this->_alerts;
case 'capability':
return $this->_capability();
case 'search_charset':
if (!isset($this->_init['search_charset'])) {
$this->_init['search_charset'] = new Horde_Imap_Client_Data_SearchCharset();
$this->_init['search_charset']->attach($this);
}
$this->_init['search_charset']->setBaseOb($this);
return $this->_init['search_charset'];
case 'url':
$url = new Horde_Imap_Client_Url();
$url->hostspec = $this->getParam('hostspec');
$url->port = $this->getParam('port');
$url->protocol = 'imap';
return $url;
}
}
/**
* Set an initialization value.
*
* @param string $key The initialization key. If null, resets all keys.
* @param mixed $val The cached value. If null, removes the key.
*/
public function _setInit($key = null, $val = null)
{
if (is_null($key)) {
$this->_init = array();
} elseif (is_null($val)) {
unset($this->_init[$key]);
} else {
switch ($key) {
case 'capability':
if ($ci = $this->getParam('capability_ignore')) {
$ignored = array();
foreach ($ci as $val2) {
$c = explode('=', $val2);
if ($val->query($c[0], isset($c[1]) ? $c[1] : null)) {
$ignored[] = $val2;
$val->remove($c[0], isset($c[1]) ? $c[1] : null);
}
}
if ($this->_debug->debug && !empty($ignored)) {
$this->_debug->info(sprintf(
'CONFIG: IGNORING these IMAP capabilities: %s',
implode(', ', $ignored)
));
}
}
$val->attach($this);
break;
}
/* Nothing has changed. */
if (isset($this->_init[$key]) && ($this->_init[$key] === $val)) {
return;
}
$this->_init[$key] = $val;
}
$this->changed = true;
}
/**
* Initialize the Horde_Imap_Client_Cache object, if necessary.
*
* @param boolean $current If true, we are going to update the currently
* selected mailbox. Add an additional check to
* see if caching is available in current
* mailbox.
*
* @return boolean Returns true if caching is enabled.
*/
protected function _initCache($current = false)
{
$c = $this->getParam('cache');
if (empty($c['fields'])) {
return false;
}
if (is_null($this->_cache)) {
if (isset($c['backend'])) {
$backend = $c['backend'];
} elseif (isset($c['cacheob'])) {
/* Deprecated */
$backend = new Horde_Imap_Client_Cache_Backend_Cache($c);
} else {
return false;
}
$this->_cache = new Horde_Imap_Client_Cache(array(
'backend' => $backend,
'baseob' => $this,
'debug' => $this->_debug
));
}
return $current
/* If UIDs are labeled as not sticky, don't cache since UIDs will
* change on every access. */
? !($this->_mailboxOb()->getStatus(Horde_Imap_Client::STATUS_UIDNOTSTICKY))
: true;
}
/**
* Returns a value from the internal params array.
*
* @param string $key The param key.
*
* @return mixed The param value, or null if not found.
*/
public function getParam($key)
{
/* Passwords may be stored encrypted. */
switch ($key) {
case 'password':
if (isset($this->_params[$key]) &&
($this->_params[$key] instanceof Horde_Imap_Client_Base_Password)) {
return $this->_params[$key]->getPassword();
}
// DEPRECATED
if (!empty($this->_params['_passencrypt'])) {
try {
$secret = new Horde_Secret();
return $secret->read($this->_getEncryptKey(), $this->_params['password']);
} catch (Exception $e) {
return null;
}
}
break;
}
return isset($this->_params[$key])
? $this->_params[$key]
: null;
}
/**
* Sets a configuration parameter value.
*
* @param string $key The param key.
* @param mixed $val The param value.
*/
public function setParam($key, $val)
{
switch ($key) {
case 'password':
if ($val instanceof Horde_Imap_Client_Base_Password) {
break;
}
// DEPRECATED: Encrypt password.
try {
$encrypt_key = $this->_getEncryptKey();
if (strlen($encrypt_key)) {
$secret = new Horde_Secret();
$val = $secret->write($encrypt_key, $val);
$this->_params['_passencrypt'] = true;
}
} catch (Exception $e) {}
break;
}
$this->_params[$key] = $val;
$this->changed = true;
}
/**
* Returns the Horde_Imap_Client_Cache object used, if available.
*
* @return mixed Either the cache object or null.
*/
public function getCache()
{
$this->_initCache();
return $this->_cache;
}
/**
* Returns the correct IDs object for use with this driver.
*
* @param mixed $ids Either self::ALL, self::SEARCH_RES, self::LARGEST,
* Horde_Imap_Client_Ids object, array, or sequence
* string.
* @param boolean $sequence Are $ids message sequence numbers?
*
* @return Horde_Imap_Client_Ids The IDs object.
*/
public function getIdsOb($ids = null, $sequence = false)
{
return new Horde_Imap_Client_Ids($ids, $sequence);
}
/**
* Returns whether the IMAP server supports the given capability
* (See RFC 3501 [6.1.1]).
*
* @deprecated Use $capability property instead.
*
* @param string $capability The capability string to query.
*
* @return mixed True if the server supports the queried capability,
* false if it doesn't, or an array if the capability can
* contain multiple values.
*/
public function queryCapability($capability)
{
try {
$c = $this->_capability();
return ($out = $c->getParams($capability))
? $out
: $c->query($capability);
} catch (Horde_Imap_Client_Exception $e) {
return false;
}
}
/**
* Get CAPABILITY information from the IMAP server.
*
* @deprecated Use $capability property instead.
*
* @return array The capability array.
*
* @throws Horde_Imap_Client_Exception
*/
public function capability()
{
return $this->_capability()->toArray();
}
/**
* Query server capability.
*
* Required because internal code can't call capability via magic method
* directly - it may not exist yet, the creation code may call capability
* recursively, and __get() doesn't allow recursive calls to the same
* property (chicken/egg issue).
*
* @return mixed The capability object if no arguments provided. If
* arguments are provided, they are passed to the query()
* method and this value is returned.
* @throws Horde_Imap_Client_Exception
*/
protected function _capability()
{
if (!isset($this->_init['capability'])) {
$this->_initCapability();
}
return ($args = func_num_args())
? $this->_init['capability']->query(func_get_arg(0), ($args > 1) ? func_get_arg(1) : null)
: $this->_init['capability'];
}
/**
* Retrieve capability information from the IMAP server.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _initCapability();
/**
* Send a NOOP command (RFC 3501 [6.1.2]).
*
* @throws Horde_Imap_Client_Exception
*/
public function noop()
{
if (!$this->_connection) {
// NOOP can be called in the unauthenticated state.
$this->_connect();
}
$this->_noop();
}
/**
* Send a NOOP command.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _noop();
/**
* Get the NAMESPACE information from the IMAP server (RFC 2342).
*
* @param array $additional If the server supports namespaces, any
* additional namespaces to add to the
* namespace list that are not broadcast by
* the server. The namespaces must be UTF-8
* strings.
* @param array $opts Additional options:
* - ob_return: (boolean) If true, returns a
* Horde_Imap_Client_Namespace_List object instead of an
* array.
*
* @return mixed A Horde_Imap_Client_Namespace_List object if
* 'ob_return', is true. Otherwise, an array of namespace
* objects (@deprecated) with the name as the key (UTF-8)
* and the following values:
*
* - delimiter: (string) The namespace delimiter.
* - hidden: (boolean) Is this a hidden namespace?
* - name: (string) The namespace name (UTF-8).
* - translation: (string) Returns the translated name of the namespace
* (UTF-8). Requires RFC 5255 and a previous call to
* setLanguage().
* - type: (integer) The namespace type. Either:
* - Horde_Imap_Client::NS_PERSONAL
* - Horde_Imap_Client::NS_OTHER
* - Horde_Imap_Client::NS_SHARED
*
*
* @throws Horde_Imap_Client_Exception
*/
public function getNamespaces(
array $additional = array(), array $opts = array()
)
{
$additional = array_map('strval', $additional);
$sig = hash(
'md5',
json_encode($additional) . intval(empty($opts['ob_return']))
);
if (isset($this->_init['namespace'][$sig])) {
$ns = $this->_init['namespace'][$sig];
} else {
$this->login();
$ns = $this->_getNamespaces();
/* Skip namespaces if we have already auto-detected them. Also,
* hidden namespaces cannot be empty. */
$to_process = array_diff(array_filter($additional, 'strlen'), array_map('strlen', iterator_to_array($ns)));
if (!empty($to_process)) {
foreach ($this->listMailboxes($to_process, Horde_Imap_Client::MBOX_ALL, array('delimiter' => true)) as $key => $val) {
$ob = new Horde_Imap_Client_Data_Namespace();
$ob->delimiter = $val['delimiter'];
$ob->hidden = true;
$ob->name = $key;
$ob->type = $ob::NS_SHARED;
$ns[$val] = $ob;
}
}
if (!count($ns)) {
/* This accurately determines the namespace information of the
* base namespace if the NAMESPACE command is not supported.
* See: RFC 3501 [6.3.8] */
$mbox = $this->listMailboxes('', Horde_Imap_Client::MBOX_ALL, array('delimiter' => true));
$first = reset($mbox);
$ob = new Horde_Imap_Client_Data_Namespace();
$ob->delimiter = $first['delimiter'];
$ns[''] = $ob;
}
$this->_init['namespace'][$sig] = $ns;
$this->_setInit('namespace', $this->_init['namespace']);
}
if (!empty($opts['ob_return'])) {
return $ns;
}
/* @todo Remove for 3.0 */
$out = array();
foreach ($ns as $key => $val) {
$out[$key] = array(
'delimiter' => $val->delimiter,
'hidden' => $val->hidden,
'name' => $val->name,
'translation' => $val->translation,
'type' => $val->type
);
}
return $out;
}
/**
* Get the NAMESPACE information from the IMAP server.
*
* @return Horde_Imap_Client_Namespace_List Namespace list object.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getNamespaces();
/**
* Display if connection to the server has been secured via TLS or SSL.
*
* @return boolean True if the IMAP connection is secured.
*/
public function isSecureConnection()
{
return ($this->_connection && $this->_connection->secure);
}
/**
* Connect to the remote server.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _connect();
/**
* Return a list of alerts that MUST be presented to the user (RFC 3501
* [7.1]).
*
* @deprecated Add an observer to the $alerts_ob property instead.
*
* @return array An array of alert messages.
*/
public function alerts()
{
$alerts = isset($this->_temp['alerts'])
? $this->_temp['alerts']
: array();
unset($this->_temp['alerts']);
return $alerts;
}
/**
* Login to the IMAP server.
*
* @throws Horde_Imap_Client_Exception
*/
public function login()
{
if (!$this->_isAuthenticated && $this->_login()) {
if ($this->getParam('id')) {
try {
$this->sendID();
/* ID is queued - force sending the queued command. */
$this->_sendCmd($this->_pipeline());
} catch (Horde_Imap_Client_Exception_NoSupportExtension $e) {
// Ignore if server doesn't support ID extension.
}
}
if ($this->getParam('comparator')) {
try {
$this->setComparator();
} catch (Horde_Imap_Client_Exception_NoSupportExtension $e) {
// Ignore if server doesn't support I18NLEVEL=2
}
}
}
$this->_isAuthenticated = true;
}
/**
* Login to the IMAP server.
*
* @return boolean Return true if global login tasks should be run.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _login();
/**
* Logout from the IMAP server (see RFC 3501 [6.1.3]).
*/
public function logout()
{
if ($this->_isAuthenticated && $this->_connection->connected) {
$this->_logout();
$this->_connection->close();
}
$this->_connection = $this->_selected = null;
$this->_isAuthenticated = false;
$this->_mode = 0;
}
/**
* Logout from the IMAP server (see RFC 3501 [6.1.3]).
*/
abstract protected function _logout();
/**
* Send ID information to the IMAP server (RFC 2971).
*
* @param array $info Overrides the value of the 'id' param and sends
* this information instead.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function sendID($info = null)
{
if (!$this->_capability('ID')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('ID');
}
$this->_sendID(is_null($info) ? ($this->getParam('id') ?: array()) : $info);
}
/**
* Send ID information to the IMAP server (RFC 2971).
*
* @param array $info The information to send to the server.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _sendID($info);
/**
* Return ID information from the IMAP server (RFC 2971).
*
* @return array An array of information returned, with the keys as the
* 'field' and the values as the 'value'.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function getID()
{
if (!$this->_capability('ID')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('ID');
}
return $this->_getID();
}
/**
* Return ID information from the IMAP server (RFC 2971).
*
* @return array An array of information returned, with the keys as the
* 'field' and the values as the 'value'.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getID();
/**
* Sets the preferred language for server response messages (RFC 5255).
*
* @param array $langs Overrides the value of the 'lang' param and sends
* this list of preferred languages instead. The
* special string 'i-default' can be used to restore
* the language to the server default.
*
* @return string The language accepted by the server, or null if the
* default language is used.
*
* @throws Horde_Imap_Client_Exception
*/
public function setLanguage($langs = null)
{
$lang = null;
if ($this->_capability('LANGUAGE')) {
$lang = is_null($langs)
? $this->getParam('lang')
: $langs;
}
return is_null($lang)
? null
: $this->_setLanguage($lang);
}
/**
* Sets the preferred language for server response messages (RFC 5255).
*
* @param array $langs The preferred list of languages.
*
* @return string The language accepted by the server, or null if the
* default language is used.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _setLanguage($langs);
/**
* Gets the preferred language for server response messages (RFC 5255).
*
* @param array $list If true, return the list of available languages.
*
* @return mixed If $list is true, the list of languages available on the
* server (may be empty). If false, the language used by
* the server, or null if the default language is used.
*
* @throws Horde_Imap_Client_Exception
*/
public function getLanguage($list = false)
{
if (!$this->_capability('LANGUAGE')) {
return $list ? array() : null;
}
return $this->_getLanguage($list);
}
/**
* Gets the preferred language for server response messages (RFC 5255).
*
* @param array $list If true, return the list of available languages.
*
* @return mixed If $list is true, the list of languages available on the
* server (may be empty). If false, the language used by
* the server, or null if the default language is used.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getLanguage($list);
/**
* Open a mailbox.
*
* @param mixed $mailbox The mailbox to open. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param integer $mode The access mode. Either
* - Horde_Imap_Client::OPEN_READONLY
* - Horde_Imap_Client::OPEN_READWRITE
* - Horde_Imap_Client::OPEN_AUTO
*
* @throws Horde_Imap_Client_Exception
*/
public function openMailbox($mailbox, $mode = Horde_Imap_Client::OPEN_AUTO)
{
$this->login();
$change = false;
$mailbox = Horde_Imap_Client_Mailbox::get($mailbox);
if ($mode == Horde_Imap_Client::OPEN_AUTO) {
if (is_null($this->_selected) ||
!$mailbox->equals($this->_selected)) {
$mode = Horde_Imap_Client::OPEN_READONLY;
$change = true;
}
} else {
$change = (is_null($this->_selected) ||
!$mailbox->equals($this->_selected) ||
($mode != $this->_mode));
}
if ($change) {
$this->_openMailbox($mailbox, $mode);
$this->_mailboxOb()->open = true;
if ($this->_initCache(true)) {
$this->_condstoreSync();
}
}
}
/**
* Open a mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox to open.
* @param integer $mode The access mode.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _openMailbox(Horde_Imap_Client_Mailbox $mailbox,
$mode);
/**
* Called when the selected mailbox is changed.
*
* @param mixed $mailbox The selected mailbox or null.
* @param integer $mode The access mode.
*/
protected function _changeSelected($mailbox = null, $mode = null)
{
$this->_mode = $mode;
if (is_null($mailbox)) {
$this->_selected = null;
} else {
$this->_selected = clone $mailbox;
$this->_mailboxOb()->reset();
}
}
/**
* Return the Horde_Imap_Client_Base_Mailbox object.
*
* @param string $mailbox The mailbox name. Defaults to currently
* selected mailbox.
*
* @return Horde_Imap_Client_Base_Mailbox Mailbox object.
*/
protected function _mailboxOb($mailbox = null)
{
$name = is_null($mailbox)
? strval($this->_selected)
: strval($mailbox);
if (!isset($this->_temp['mailbox_ob'][$name])) {
$this->_temp['mailbox_ob'][$name] = new Horde_Imap_Client_Base_Mailbox();
}
return $this->_temp['mailbox_ob'][$name];
}
/**
* Return the currently opened mailbox and access mode.
*
* @return mixed Null if no mailbox selected, or an array with two
* elements:
* - mailbox: (Horde_Imap_Client_Mailbox) The mailbox object.
* - mode: (integer) Current mode.
*
* @throws Horde_Imap_Client_Exception
*/
public function currentMailbox()
{
return is_null($this->_selected)
? null
: array(
'mailbox' => clone $this->_selected,
'mode' => $this->_mode
);
}
/**
* Create a mailbox.
*
* @param mixed $mailbox The mailbox to create. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param array $opts Additional options:
* - special_use: (array) An array of special-use flags to mark the
* mailbox with. The server MUST support RFC 6154.
*
* @throws Horde_Imap_Client_Exception
*/
public function createMailbox($mailbox, array $opts = array())
{
$this->login();
if (!$this->_capability('CREATE-SPECIAL-USE')) {
unset($opts['special_use']);
}
$this->_createMailbox(Horde_Imap_Client_Mailbox::get($mailbox), $opts);
}
/**
* Create a mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox to create.
* @param array $opts Additional options. See
* createMailbox().
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _createMailbox(Horde_Imap_Client_Mailbox $mailbox,
$opts);
/**
* Delete a mailbox.
*
* @param mixed $mailbox The mailbox to delete. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
*
* @throws Horde_Imap_Client_Exception
*/
public function deleteMailbox($mailbox)
{
$this->login();
$mailbox = Horde_Imap_Client_Mailbox::get($mailbox);
$this->_deleteMailbox($mailbox);
$this->_deleteMailboxPost($mailbox);
}
/**
* Delete a mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox to delete.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _deleteMailbox(Horde_Imap_Client_Mailbox $mailbox);
/**
* Actions to perform after a mailbox delete.
*
* @param Horde_Imap_Client_Mailbox $mailbox The deleted mailbox.
*/
protected function _deleteMailboxPost(Horde_Imap_Client_Mailbox $mailbox)
{
/* Delete mailbox caches. */
if ($this->_initCache()) {
$this->_cache->deleteMailbox($mailbox);
}
unset($this->_temp['mailbox_ob'][strval($mailbox)]);
/* Unsubscribe from mailbox. */
try {
$this->subscribeMailbox($mailbox, false);
} catch (Horde_Imap_Client_Exception $e) {
// Ignore failed unsubscribe request
}
}
/**
* Rename a mailbox.
*
* @param mixed $old The old mailbox name. Either a
* Horde_Imap_Client_Mailbox object or a string (UTF-8).
* @param mixed $new The new mailbox name. Either a
* Horde_Imap_Client_Mailbox object or a string (UTF-8).
*
* @throws Horde_Imap_Client_Exception
*/
public function renameMailbox($old, $new)
{
// Login will be handled by first listMailboxes() call.
$old = Horde_Imap_Client_Mailbox::get($old);
$new = Horde_Imap_Client_Mailbox::get($new);
/* Check if old mailbox(es) were subscribed to. */
$base = $this->listMailboxes($old, Horde_Imap_Client::MBOX_SUBSCRIBED, array('delimiter' => true));
if (empty($base)) {
$base = $this->listMailboxes($old, Horde_Imap_Client::MBOX_ALL, array('delimiter' => true));
$base = reset($base);
$subscribed = array();
} else {
$base = reset($base);
$subscribed = array($base['mailbox']);
}
$all_mboxes = array($base['mailbox']);
if (strlen($base['delimiter'])) {
$search = $old->list_escape . $base['delimiter'] . '*';
$all_mboxes = array_merge($all_mboxes, $this->listMailboxes($search, Horde_Imap_Client::MBOX_ALL, array('flat' => true)));
$subscribed = array_merge($subscribed, $this->listMailboxes($search, Horde_Imap_Client::MBOX_SUBSCRIBED, array('flat' => true)));
}
$this->_renameMailbox($old, $new);
/* Delete mailbox actions. */
foreach ($all_mboxes as $val) {
$this->_deleteMailboxPost($val);
}
foreach ($subscribed as $val) {
try {
$this->subscribeMailbox(new Horde_Imap_Client_Mailbox(substr_replace($val, $new, 0, strlen($old))));
} catch (Horde_Imap_Client_Exception $e) {
// Ignore failed subscription requests
}
}
}
/**
* Rename a mailbox.
*
* @param Horde_Imap_Client_Mailbox $old The old mailbox name.
* @param Horde_Imap_Client_Mailbox $new The new mailbox name.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _renameMailbox(Horde_Imap_Client_Mailbox $old,
Horde_Imap_Client_Mailbox $new);
/**
* Manage subscription status for a mailbox.
*
* @param mixed $mailbox The mailbox to [un]subscribe to. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param boolean $subscribe True to subscribe, false to unsubscribe.
*
* @throws Horde_Imap_Client_Exception
*/
public function subscribeMailbox($mailbox, $subscribe = true)
{
$this->login();
$this->_subscribeMailbox(Horde_Imap_Client_Mailbox::get($mailbox), (bool)$subscribe);
}
/**
* Manage subscription status for a mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox to [un]subscribe
* to.
* @param boolean $subscribe True to subscribe, false to
* unsubscribe.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _subscribeMailbox(Horde_Imap_Client_Mailbox $mailbox,
$subscribe);
/**
* Obtain a list of mailboxes matching a pattern.
*
* @param mixed $pattern The mailbox search pattern(s) (see RFC 3501
* [6.3.8] for the format). A UTF-8 string or an
* array of strings. If a Horde_Imap_Client_Mailbox
* object is given, it is escaped (i.e. wildcard
* patterns are converted to return the miminal
* number of matches possible).
* @param integer $mode Which mailboxes to return. Either:
* - Horde_Imap_Client::MBOX_SUBSCRIBED
* Return subscribed mailboxes.
* - Horde_Imap_Client::MBOX_SUBSCRIBED_EXISTS
* Return subscribed mailboxes that exist on the server.
* - Horde_Imap_Client::MBOX_UNSUBSCRIBED
* Return unsubscribed mailboxes.
* - Horde_Imap_Client::MBOX_ALL
* Return all mailboxes regardless of subscription status.
* - Horde_Imap_Client::MBOX_ALL_SUBSCRIBED (@since 2.23.0)
* Return all mailboxes regardless of subscription status, and ensure
* the '\subscribed' attribute is set if mailbox is subscribed
* (implies 'attributes' option is true).
* @param array $options Additional options:
*
* - attributes: (boolean) If true, return attribute information under
* the 'attributes' key.
* DEFAULT: Do not return this information.
* - children: (boolean) Tell server to return children attribute
* information (\HasChildren, \HasNoChildren). Requires the
* LIST-EXTENDED extension to guarantee this information is
* returned. Server MAY return this attribute without this
* option, or if the CHILDREN extension is available, but it
* is not guaranteed.
* DEFAULT: false
* - flat: (boolean) If true, return a flat list of mailbox names only.
* Overrides the 'attributes' option.
* DEFAULT: Do not return flat list.
* - recursivematch: (boolean) Force the server to return information
* about parent mailboxes that don't match other
* selection options, but have some sub-mailboxes that
* do. Information about children is returned in the
* CHILDINFO extended data item ('extended'). Requires
* the LIST-EXTENDED extension.
* DEFAULT: false
* - remote: (boolean) Tell server to return mailboxes that reside on
* another server. Requires the LIST-EXTENDED extension.
* DEFAULT: false
* - special_use: (boolean) Tell server to return special-use attribute
* information (see Horde_Imap_Client SPECIALUSE_*
* constants). Server must support the SPECIAL-USE return
* option for this setting to have any effect.
* DEFAULT: false
* - status: (integer) Tell server to return status information. The
* value is a bitmask that may contain any of:
* - Horde_Imap_Client::STATUS_MESSAGES
* - Horde_Imap_Client::STATUS_RECENT
* - Horde_Imap_Client::STATUS_UIDNEXT
* - Horde_Imap_Client::STATUS_UIDVALIDITY
* - Horde_Imap_Client::STATUS_UNSEEN
* - Horde_Imap_Client::STATUS_HIGHESTMODSEQ
* DEFAULT: 0
* - sort: (boolean) If true, return a sorted list of mailboxes?
* DEFAULT: Do not sort the list.
* - sort_delimiter: (string) If 'sort' is true, this is the delimiter
* used to sort the mailboxes.
* DEFAULT: '.'
*
*
* @return array If 'flat' option is true, the array values are a list
* of Horde_Imap_Client_Mailbox objects. Otherwise, the
* keys are UTF-8 mailbox names and the values are arrays
* with these keys:
* - attributes: (array) List of lower-cased attributes [only if
* 'attributes' option is true].
* - delimiter: (string) The delimiter for the mailbox.
* - extended: (TODO) TODO [only if 'recursivematch' option is true and
* LIST-EXTENDED extension is supported on the server].
* - mailbox: (Horde_Imap_Client_Mailbox) The mailbox object.
* - status: (array) See status() [only if 'status' option is true].
*
* @throws Horde_Imap_Client_Exception
*/
public function listMailboxes($pattern,
$mode = Horde_Imap_Client::MBOX_ALL,
array $options = array())
{
$this->login();
$pattern = is_array($pattern)
? array_unique($pattern)
: array($pattern);
/* Prepare patterns. */
$plist = array();
foreach ($pattern as $val) {
if ($val instanceof Horde_Imap_Client_Mailbox) {
$val = $val->list_escape;
}
$plist[] = Horde_Imap_Client_Mailbox::get(preg_replace(
array("/\*{2,}/", "/\%{2,}/"),
array('*', '%'),
Horde_Imap_Client_Utf7imap::Utf8ToUtf7Imap($val)
), true);
}
if (isset($options['special_use']) &&
!$this->_capability('SPECIAL-USE')) {
unset($options['special_use']);
}
$ret = $this->_listMailboxes($plist, $mode, $options);
if (!empty($options['status']) &&
!$this->_capability('LIST-STATUS')) {
foreach ($this->status(array_keys($ret), $options['status']) as $key => $val) {
$ret[$key]['status'] = $val;
}
}
if (empty($options['sort'])) {
return $ret;
}
$list_ob = new Horde_Imap_Client_Mailbox_List(empty($options['flat']) ? array_keys($ret) : $ret);
$sorted = $list_ob->sort(array(
'delimiter' => empty($options['sort_delimiter']) ? '.' : $options['sort_delimiter']
));
if (!empty($options['flat'])) {
return $sorted;
}
$out = array();
foreach ($sorted as $val) {
$out[$val] = $ret[$val];
}
return $out;
}
/**
* Obtain a list of mailboxes matching a pattern.
*
* @param array $pattern The mailbox search patterns
* (Horde_Imap_Client_Mailbox objects).
* @param integer $mode Which mailboxes to return.
* @param array $options Additional options.
*
* @return array See listMailboxes().
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _listMailboxes($pattern, $mode, $options);
/**
* Obtain status information for a mailbox.
*
* @param mixed $mailbox The mailbox(es) to query. Either a
* Horde_Imap_Client_Mailbox object, a string
* (UTF-8), or an array of objects/strings (since
* 2.10.0).
* @param integer $flags A bitmask of information requested from the
* server. Allowed flags:
*
* - Horde_Imap_Client::STATUS_MESSAGES
* Return key: messages
* Return format: (integer) The number of messages in the mailbox.
*
* - Horde_Imap_Client::STATUS_RECENT
* Return key: recent
* Return format: (integer) The number of messages with the \Recent
* flag set as currently reported in the mailbox
*
* - Horde_Imap_Client::STATUS_RECENT_TOTAL
* Return key: recent_total
* Return format: (integer) The number of messages with the \Recent
* flag set. This returns the total number of messages
* that have been marked as recent in this mailbox
* since the PHP process began. (since 2.12.0)
*
* - Horde_Imap_Client::STATUS_UIDNEXT
* Return key: uidnext
* Return format: (integer) The next UID to be assigned in the
* mailbox. Only returned if the server automatically
* provides the data.
*
* - Horde_Imap_Client::STATUS_UIDNEXT_FORCE
* Return key: uidnext
* Return format: (integer) The next UID to be assigned in the
* mailbox. This option will always determine this
* value, even if the server does not automatically
* provide this data.
*
* - Horde_Imap_Client::STATUS_UIDVALIDITY
* Return key: uidvalidity
* Return format: (integer) The unique identifier validity of the
* mailbox.
*
* - Horde_Imap_Client::STATUS_UNSEEN
* Return key: unseen
* Return format: (integer) The number of messages which do not have
* the \Seen flag set.
*
* - Horde_Imap_Client::STATUS_FIRSTUNSEEN
* Return key: firstunseen
* Return format: (integer) The sequence number of the first unseen
* message in the mailbox.
*
* - Horde_Imap_Client::STATUS_FLAGS
* Return key: flags
* Return format: (array) The list of defined flags in the mailbox
* (all flags are in lowercase).
*
* - Horde_Imap_Client::STATUS_PERMFLAGS
* Return key: permflags
* Return format: (array) The list of flags that a client can change
* permanently (all flags are in lowercase).
*
* - Horde_Imap_Client::STATUS_HIGHESTMODSEQ
* Return key: highestmodseq
* Return format: (integer) If the server supports the CONDSTORE
* IMAP extension, this will be the highest
* mod-sequence value of all messages in the mailbox.
* Else 0 if CONDSTORE not available or the mailbox
* does not support mod-sequences.
*
* - Horde_Imap_Client::STATUS_SYNCMODSEQ
* Return key: syncmodseq
* Return format: (integer) If caching, and the server supports the
* CONDSTORE IMAP extension, this is the cached
* mod-sequence value of the mailbox when it was opened
* for the first time in this access. Will be null if
* not caching, CONDSTORE not available, or the mailbox
* does not support mod-sequences.
*
* - Horde_Imap_Client::STATUS_SYNCFLAGUIDS
* Return key: syncflaguids
* Return format: (Horde_Imap_Client_Ids) If caching, the server
* supports the CONDSTORE IMAP extension, and the
* mailbox contained cached data when opened for the
* first time in this access, this is the list of UIDs
* in which flags have changed since STATUS_SYNCMODSEQ.
*
* - Horde_Imap_Client::STATUS_SYNCVANISHED
* Return key: syncvanished
* Return format: (Horde_Imap_Client_Ids) If caching, the server
* supports the CONDSTORE IMAP extension, and the
* mailbox contained cached data when opened for the
* first time in this access, this is the list of UIDs
* which have been deleted since STATUS_SYNCMODSEQ.
*
* - Horde_Imap_Client::STATUS_UIDNOTSTICKY
* Return key: uidnotsticky
* Return format: (boolean) If the server supports the UIDPLUS IMAP
* extension, and the queried mailbox does not support
* persistent UIDs, this value will be true. In all
* other cases, this value will be false.
*
* - Horde_Imap_Client::STATUS_FORCE_REFRESH
* Normally, the status information will be cached for a given
* mailbox. Since most PHP requests are generally less than a second,
* this is fine. However, if your script is long running, the status
* information may not be up-to-date. Specifying this flag will ensure
* that the server is always polled for the current mailbox status
* before results are returned. (since 2.14.0)
*
* - Horde_Imap_Client::STATUS_ALL (DEFAULT)
* Shortcut to return 'messages', 'recent', 'uidnext', 'uidvalidity',
* and 'unseen' values.
*
* @param array $opts Additional options:
*
* - sort: (boolean) If true, sort the list of mailboxes? (since 2.10.0)
* DEFAULT: Do not sort the list.
* - sort_delimiter: (string) If 'sort' is true, this is the delimiter
* used to sort the mailboxes. (since 2.10.0)
* DEFAULT: '.'
*
*
* @return array If $mailbox contains multiple mailboxes, an array with
* keys being the UTF-8 mailbox name and values as arrays
* containing the requested keys (see above).
* Otherwise, an array with keys as the requested keys (see
* above) and values as the key data.
*
* @throws Horde_Imap_Client_Exception
*/
public function status($mailbox, $flags = Horde_Imap_Client::STATUS_ALL,
array $opts = array())
{
$opts = array_merge(array(
'sort' => false,
'sort_delimiter' => '.'
), $opts);
$this->login();
if (is_array($mailbox)) {
if (empty($mailbox)) {
return array();
}
$ret_array = true;
} else {
$mailbox = array($mailbox);
$ret_array = false;
}
$mlist = array_map(array('Horde_Imap_Client_Mailbox', 'get'), $mailbox);
$unselected_flags = array(
'messages' => Horde_Imap_Client::STATUS_MESSAGES,
'recent' => Horde_Imap_Client::STATUS_RECENT,
'uidnext' => Horde_Imap_Client::STATUS_UIDNEXT,
'uidvalidity' => Horde_Imap_Client::STATUS_UIDVALIDITY,
'unseen' => Horde_Imap_Client::STATUS_UNSEEN
);
if (!$this->statuscache) {
$flags |= Horde_Imap_Client::STATUS_FORCE_REFRESH;
}
if ($flags & Horde_Imap_Client::STATUS_ALL) {
foreach ($unselected_flags as $val) {
$flags |= $val;
}
}
$master = $ret = array();
/* Catch flags that are not supported. */
if (($flags & Horde_Imap_Client::STATUS_HIGHESTMODSEQ) &&
!$this->_capability()->isEnabled('CONDSTORE')) {
$master['highestmodseq'] = 0;
$flags &= ~Horde_Imap_Client::STATUS_HIGHESTMODSEQ;
}
if (($flags & Horde_Imap_Client::STATUS_UIDNOTSTICKY) &&
!$this->_capability('UIDPLUS')) {
$master['uidnotsticky'] = false;
$flags &= ~Horde_Imap_Client::STATUS_UIDNOTSTICKY;
}
/* UIDNEXT return options. */
if ($flags & Horde_Imap_Client::STATUS_UIDNEXT_FORCE) {
$flags |= Horde_Imap_Client::STATUS_UIDNEXT;
}
foreach ($mlist as $val) {
$name = strval($val);
$tmp_flags = $flags;
if ($val->equals($this->_selected)) {
/* Check if already in mailbox. */
$opened = true;
if ($flags & Horde_Imap_Client::STATUS_FORCE_REFRESH) {
$this->noop();
}
} else {
/* A list of STATUS options (other than those handled directly
* below) that require the mailbox to be explicitly opened. */
$opened = ($flags & Horde_Imap_Client::STATUS_FIRSTUNSEEN) ||
($flags & Horde_Imap_Client::STATUS_FLAGS) ||
($flags & Horde_Imap_Client::STATUS_PERMFLAGS) ||
($flags & Horde_Imap_Client::STATUS_UIDNOTSTICKY) ||
/* Force mailboxes containing wildcards to be accessed via
* STATUS so that wildcards do not return a bunch of
* mailboxes in the LIST-STATUS response. */
(strpbrk($name, '*%') !== false);
}
$ret[$name] = $master;
$ptr = &$ret[$name];
/* STATUS_PERMFLAGS requires a read/write mailbox. */
if ($flags & Horde_Imap_Client::STATUS_PERMFLAGS) {
$this->openMailbox($val, Horde_Imap_Client::OPEN_READWRITE);
$opened = true;
}
/* Handle SYNC related return options. These require the mailbox
* to be opened at least once. */
if ($flags & Horde_Imap_Client::STATUS_SYNCMODSEQ) {
$this->openMailbox($val);
$ptr['syncmodseq'] = $this->_mailboxOb($val)->getStatus(Horde_Imap_Client::STATUS_SYNCMODSEQ);
$tmp_flags &= ~Horde_Imap_Client::STATUS_SYNCMODSEQ;
$opened = true;
}
if ($flags & Horde_Imap_Client::STATUS_SYNCFLAGUIDS) {
$this->openMailbox($val);
$ptr['syncflaguids'] = $this->getIdsOb($this->_mailboxOb($val)->getStatus(Horde_Imap_Client::STATUS_SYNCFLAGUIDS));
$tmp_flags &= ~Horde_Imap_Client::STATUS_SYNCFLAGUIDS;
$opened = true;
}
if ($flags & Horde_Imap_Client::STATUS_SYNCVANISHED) {
$this->openMailbox($val);
$ptr['syncvanished'] = $this->getIdsOb($this->_mailboxOb($val)->getStatus(Horde_Imap_Client::STATUS_SYNCVANISHED));
$tmp_flags &= ~Horde_Imap_Client::STATUS_SYNCVANISHED;
$opened = true;
}
/* Handle RECENT_TOTAL option. */
if ($flags & Horde_Imap_Client::STATUS_RECENT_TOTAL) {
$this->openMailbox($val);
$ptr['recent_total'] = $this->_mailboxOb($val)->getStatus(Horde_Imap_Client::STATUS_RECENT_TOTAL);
$tmp_flags &= ~Horde_Imap_Client::STATUS_RECENT_TOTAL;
$opened = true;
}
if ($opened) {
if ($tmp_flags) {
$tmp = $this->_status(array($val), $tmp_flags);
$ptr += reset($tmp);
}
} else {
$to_process[] = $val;
}
}
if ($flags && !empty($to_process)) {
if ((count($to_process) > 1) &&
$this->_capability('LIST-STATUS')) {
foreach ($this->listMailboxes($to_process, Horde_Imap_Client::MBOX_ALL, array('status' => $flags)) as $key => $val) {
if (isset($val['status'])) {
$ret[$key] += $val['status'];
}
}
} else {
foreach ($this->_status($to_process, $flags) as $key => $val) {
$ret[$key] += $val;
}
}
}
if (!$opts['sort'] || (count($ret) === 1)) {
return $ret_array
? $ret
: reset($ret);
}
$list_ob = new Horde_Imap_Client_Mailbox_List(array_keys($ret));
$sorted = $list_ob->sort(array(
'delimiter' => $opts['sort_delimiter']
));
$out = array();
foreach ($sorted as $val) {
$out[$val] = $ret[$val];
}
return $out;
}
/**
* Obtain status information for mailboxes.
*
* @param array $mboxes The list of mailbox objects to query.
* @param integer $flags A bitmask of information requested from the
* server.
*
* @return array See array return for status().
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _status($mboxes, $flags);
/**
* Perform a STATUS call on multiple mailboxes at the same time.
*
* This method leverages the LIST-EXTENDED and LIST-STATUS extensions on
* the IMAP server to improve the efficiency of this operation.
*
* @deprecated Use status() instead.
*
* @param array $mailboxes The mailboxes to query. Either
* Horde_Imap_Client_Mailbox objects, strings
* (UTF-8), or a combination of the two.
* @param integer $flags See status().
* @param array $opts Additional options:
* - sort: (boolean) If true, sort the list of mailboxes?
* DEFAULT: Do not sort the list.
* - sort_delimiter: (string) If 'sort' is true, this is the delimiter
* used to sort the mailboxes.
* DEFAULT: '.'
*
* @return array An array with the keys as the mailbox names (UTF-8) and
* the values as arrays with the requested keys (from the
* mask given in $flags).
*/
public function statusMultiple($mailboxes,
$flags = Horde_Imap_Client::STATUS_ALL,
array $opts = array())
{
return $this->status($mailboxes, $flags, $opts);
}
/**
* Append message(s) to a mailbox.
*
* @param mixed $mailbox The mailbox to append the message(s) to. Either
* a Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param array $data The message data to append, along with
* additional options. An array of arrays with
* each embedded array having the following
* entries:
*
* - data: (mixed) The data to append. If a string or a stream resource,
* this will be used as the entire contents of a single message.
* If an array, will catenate all given parts into a single
* message. This array contains one or more arrays with
* two keys:
* - t: (string) Either 'url' or 'text'.
* - v: (mixed) If 't' is 'url', this is the IMAP URL to the message
* part to append. If 't' is 'text', this is either a string or
* resource representation of the message part data.
* DEFAULT: NONE (entry is MANDATORY)
* - flags: (array) An array of flags/keywords to set on the appended
* message.
* DEFAULT: Only the \Recent flag is set.
* - internaldate: (DateTime) The internaldate to set for the appended
* message.
* DEFAULT: internaldate will be the same date as when
* the message was appended.
*
* @param array $options Additonal options:
*
* - create: (boolean) Try to create $mailbox if it does not exist?
* DEFAULT: No.
*
*
* @return Horde_Imap_Client_Ids The UIDs of the appended messages.
*
* @throws Horde_Imap_Client_Exception
*/
public function append($mailbox, $data, array $options = array())
{
$this->login();
$mailbox = Horde_Imap_Client_Mailbox::get($mailbox);
$ret = $this->_append($mailbox, $data, $options);
if ($ret instanceof Horde_Imap_Client_Ids) {
return $ret;
}
$uids = $this->getIdsOb();
foreach ($data as $val) {
if (is_resource($val['data'])) {
rewind($val['data']);
}
$uids->add($this->_getUidByMessageId(
$mailbox,
Horde_Mime_Headers::parseHeaders($val['data'])->getHeader('Message-ID')
));
}
return $uids;
}
/**
* Append message(s) to a mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox to append the
* message(s) to.
* @param array $data The message data.
* @param array $options Additional options.
*
* @return mixed A Horde_Imap_Client_Ids object containing the UIDs of
* the appended messages (if server supports UIDPLUS
* extension) or true.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _append(Horde_Imap_Client_Mailbox $mailbox,
$data, $options);
/**
* Request a checkpoint of the currently selected mailbox (RFC 3501
* [6.4.1]).
*
* @throws Horde_Imap_Client_Exception
*/
public function check()
{
// CHECK only useful if we are already authenticated.
if ($this->_isAuthenticated) {
$this->_check();
}
}
/**
* Request a checkpoint of the currently selected mailbox.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _check();
/**
* Close the connection to the currently selected mailbox, optionally
* expunging all deleted messages (RFC 3501 [6.4.2]).
*
* @param array $options Additional options:
* - expunge: (boolean) Expunge all messages flagged as deleted?
* DEFAULT: No
*
* @throws Horde_Imap_Client_Exception
*/
public function close(array $options = array())
{
// This check catches the non-logged in case.
if (is_null($this->_selected)) {
return;
}
/* If we are caching, search for deleted messages. */
if (!empty($options['expunge']) && $this->_initCache(true)) {
/* Make sure mailbox is read-write to expunge. */
$this->openMailbox($this->_selected, Horde_Imap_Client::OPEN_READWRITE);
if ($this->_mode == Horde_Imap_Client::OPEN_READONLY) {
throw new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("Cannot expunge read-only mailbox."),
Horde_Imap_Client_Exception::MAILBOX_READONLY
);
}
$search_query = new Horde_Imap_Client_Search_Query();
$search_query->flag(Horde_Imap_Client::FLAG_DELETED, true);
$search_res = $this->search($this->_selected, $search_query);
$mbox = $this->_selected;
} else {
$search_res = null;
}
$this->_close($options);
$this->_selected = null;
$this->_mode = 0;
if (!is_null($search_res)) {
$this->_deleteMsgs($mbox, $search_res['match']);
}
}
/**
* Close the connection to the currently selected mailbox, optionally
* expunging all deleted messages (RFC 3501 [6.4.2]).
*
* @param array $options Additional options.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _close($options);
/**
* Expunge deleted messages from the given mailbox.
*
* @param mixed $mailbox The mailbox to expunge. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param array $options Additional options:
* - delete: (boolean) If true, will flag all messages in 'ids' as
* deleted (since 2.10.0).
* DEFAULT: false
* - ids: (Horde_Imap_Client_Ids) A list of messages to expunge. These
* messages must already be flagged as deleted (unless 'delete'
* is true).
* DEFAULT: All messages marked as deleted will be expunged.
* - list: (boolean) If true, returns the list of expunged messages
* (UIDs only).
* DEFAULT: false
*
* @return Horde_Imap_Client_Ids If 'list' option is true, returns the
* UID list of expunged messages.
*
* @throws Horde_Imap_Client_Exception
*/
public function expunge($mailbox, array $options = array())
{
// Open mailbox call will handle the login.
$this->openMailbox($mailbox, Horde_Imap_Client::OPEN_READWRITE);
/* Don't expunge if the mailbox is readonly. */
if ($this->_mode == Horde_Imap_Client::OPEN_READONLY) {
throw new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("Cannot expunge read-only mailbox."),
Horde_Imap_Client_Exception::MAILBOX_READONLY
);
}
if (empty($options['ids'])) {
$options['ids'] = $this->getIdsOb(Horde_Imap_Client_Ids::ALL);
} elseif ($options['ids']->isEmpty()) {
return $this->getIdsOb();
}
return $this->_expunge($options);
}
/**
* Expunge all deleted messages from the given mailbox.
*
* @param array $options Additional options.
*
* @return Horde_Imap_Client_Ids If 'list' option is true, returns the
* list of expunged messages.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _expunge($options);
/**
* Search a mailbox.
*
* @param mixed $mailbox The mailbox to search.
* Either a
* Horde_Imap_Client_Mailbox
* object or a string
* (UTF-8).
* @param Horde_Imap_Client_Search_Query $query The search query.
* Defaults to an ALL
* search.
* @param array $options Additional options:
*
* - nocache: (boolean) Don't cache the results.
* DEFAULT: false (results cached, if possible)
* - partial: (mixed) The range of results to return (message sequence
* numbers) Only a single range is supported (represented by
* the minimum and maximum values contained in the range
* given).
* DEFAULT: All messages are returned.
* - results: (array) The data to return. Consists of zero or more of
* the following flags:
* - Horde_Imap_Client::SEARCH_RESULTS_COUNT
* - Horde_Imap_Client::SEARCH_RESULTS_MATCH (DEFAULT)
* - Horde_Imap_Client::SEARCH_RESULTS_MAX
* - Horde_Imap_Client::SEARCH_RESULTS_MIN
* - Horde_Imap_Client::SEARCH_RESULTS_SAVE
* - Horde_Imap_Client::SEARCH_RESULTS_RELEVANCY
* - sequence: (boolean) If true, returns an array of sequence numbers.
* DEFAULT: Returns an array of UIDs
* - sort: (array) Sort the returned list of messages. Multiple sort
* criteria can be specified. Any sort criteria can be sorted in
* reverse order (instead of the default ascending order) by
* adding a Horde_Imap_Client::SORT_REVERSE element to the array
* directly before adding the sort element. The following sort
* criteria are available:
* - Horde_Imap_Client::SORT_ARRIVAL
* - Horde_Imap_Client::SORT_CC
* - Horde_Imap_Client::SORT_DATE
* - Horde_Imap_Client::SORT_DISPLAYFROM
* On servers that don't support SORT=DISPLAY, this criteria will
* fallback to doing client-side sorting.
* - Horde_Imap_Client::SORT_DISPLAYFROM_FALLBACK
* On servers that don't support SORT=DISPLAY, this criteria will
* fallback to Horde_Imap_Client::SORT_FROM [since 2.4.0].
* - Horde_Imap_Client::SORT_DISPLAYTO
* On servers that don't support SORT=DISPLAY, this criteria will
* fallback to doing client-side sorting.
* - Horde_Imap_Client::SORT_DISPLAYTO_FALLBACK
* On servers that don't support SORT=DISPLAY, this criteria will
* fallback to Horde_Imap_Client::SORT_TO [since 2.4.0].
* - Horde_Imap_Client::SORT_FROM
* - Horde_Imap_Client::SORT_SEQUENCE
* - Horde_Imap_Client::SORT_SIZE
* - Horde_Imap_Client::SORT_SUBJECT
* - Horde_Imap_Client::SORT_TO
*
* [On servers that support SEARCH=FUZZY, this criteria is also
* available:]
* - Horde_Imap_Client::SORT_RELEVANCY
*
*
* @return array An array with the following keys:
*
* - count: (integer) The number of messages that match the search
* criteria. Always returned.
* - match: (Horde_Imap_Client_Ids) The IDs that match $criteria, sorted
* if the 'sort' modifier was set. Returned if
* Horde_Imap_Client::SEARCH_RESULTS_MATCH is set.
* - max: (integer) The UID (default) or message sequence number (if
* 'sequence' is true) of the highest message that satisifies
* $criteria. Returns null if no matches found. Returned if
* Horde_Imap_Client::SEARCH_RESULTS_MAX is set.
* - min: (integer) The UID (default) or message sequence number (if
* 'sequence' is true) of the lowest message that satisifies
* $criteria. Returns null if no matches found. Returned if
* Horde_Imap_Client::SEARCH_RESULTS_MIN is set.
* - modseq: (integer) The highest mod-sequence for all messages being
* returned. Returned if 'sort' is false, the search query
* includes a MODSEQ command, and the server supports the
* CONDSTORE IMAP extension.
* - relevancy: (array) The list of relevancy scores. Returned if
* Horde_Imap_Client::SEARCH_RESULTS_RELEVANCY is set and
* the server supports FUZZY search matching.
* - save: (boolean) Whether the search results were saved. Returned if
* Horde_Imap_Client::SEARCH_RESULTS_SAVE is set.
*
*
* @throws Horde_Imap_Client_Exception
*/
public function search($mailbox, $query = null, array $options = array())
{
$this->login();
if (empty($options['results'])) {
$options['results'] = array(
Horde_Imap_Client::SEARCH_RESULTS_MATCH,
Horde_Imap_Client::SEARCH_RESULTS_COUNT
);
} elseif (!in_array(Horde_Imap_Client::SEARCH_RESULTS_COUNT, $options['results'])) {
$options['results'][] = Horde_Imap_Client::SEARCH_RESULTS_COUNT;
}
// Default to an ALL search.
if (is_null($query)) {
$query = new Horde_Imap_Client_Search_Query();
}
// Check for SEARCHRES support.
if ((($pos = array_search(Horde_Imap_Client::SEARCH_RESULTS_SAVE, $options['results'])) !== false) &&
!$this->_capability('SEARCHRES')) {
unset($options['results'][$pos]);
}
// Check for SORT-related options.
if (!empty($options['sort'])) {
foreach ($options['sort'] as $key => $val) {
switch ($val) {
case Horde_Imap_Client::SORT_DISPLAYFROM_FALLBACK:
$options['sort'][$key] = $this->_capability('SORT', 'DISPLAY')
? Horde_Imap_Client::SORT_DISPLAYFROM
: Horde_Imap_Client::SORT_FROM;
break;
case Horde_Imap_Client::SORT_DISPLAYTO_FALLBACK:
$options['sort'][$key] = $this->_capability('SORT', 'DISPLAY')
? Horde_Imap_Client::SORT_DISPLAYTO
: Horde_Imap_Client::SORT_TO;
break;
}
}
}
/* Default search results. */
$default_ret = array(
'count' => 0,
'match' => $this->getIdsOb(),
'max' => null,
'min' => null,
'relevancy' => array()
);
/* Build search query. */
$squery = $query->build($this);
/* Check for query contents. If empty, this means that the query
* object has identified that this query can NEVER return any results.
* Immediately return now. */
if (!count($squery['query'])) {
return $default_ret;
}
// Check for supported charset.
if (!is_null($squery['charset']) &&
($this->search_charset->query($squery['charset'], true) === false)) {
foreach ($this->search_charset->charsets as $val) {
try {
$new_query = clone $query;
$new_query->charset($val);
break;
} catch (Horde_Imap_Client_Exception_SearchCharset $e) {
unset($new_query);
}
}
if (!isset($new_query)) {
throw $e;
}
$query = $new_query;
$squery = $query->build($this);
}
// Store query in $options array to pass to child method.
$options['_query'] = $squery;
/* RFC 6203: MUST NOT request relevancy results if we are not using
* FUZZY searching. */
if (in_array(Horde_Imap_Client::SEARCH_RESULTS_RELEVANCY, $options['results']) &&
!in_array('SEARCH=FUZZY', $squery['exts_used'])) {
throw new InvalidArgumentException('Cannot specify RELEVANCY results if not doing a FUZZY search.');
}
/* Check for partial matching. */
if (!empty($options['partial'])) {
$pids = $this->getIdsOb($options['partial'], true)->range_string;
if (!strlen($pids)) {
throw new InvalidArgumentException('Cannot specify empty sequence range for a PARTIAL search.');
}
if (strpos($pids, ':') === false) {
$pids .= ':' . $pids;
}
$options['partial'] = $pids;
}
/* Optimization - if query is just for a count of either RECENT or
* ALL messages, we can send status information instead. Can't
* optimize with unseen queries because we may cause an infinite loop
* between here and the status() call. */
if ((count($options['results']) === 1) &&
(reset($options['results']) == Horde_Imap_Client::SEARCH_RESULTS_COUNT)) {
switch ($squery['query']) {
case 'ALL':
$ret = $this->status($mailbox, Horde_Imap_Client::STATUS_MESSAGES);
return array('count' => $ret['messages']);
case 'RECENT':
$ret = $this->status($mailbox, Horde_Imap_Client::STATUS_RECENT);
return array('count' => $ret['recent']);
}
}
$this->openMailbox($mailbox, Horde_Imap_Client::OPEN_AUTO);
/* Take advantage of search result caching. If CONDSTORE available,
* we can cache all queries and invalidate the cache when the MODSEQ
* changes. If CONDSTORE not available, we can only store queries
* that don't involve flags. We store results by hashing the options
* array. */
$cache = null;
if (empty($options['nocache']) &&
$this->_initCache(true) &&
($this->_capability()->isEnabled('CONDSTORE') ||
!$query->flagSearch())) {
$cache = $this->_getSearchCache('search', $options);
if (isset($cache['data'])) {
if (isset($cache['data']['match'])) {
$cache['data']['match'] = $this->getIdsOb($cache['data']['match']);
}
return $cache['data'];
}
}
/* Optimization: Catch when there are no messages in a mailbox. */
$status_res = $this->status($this->_selected, Horde_Imap_Client::STATUS_MESSAGES | Horde_Imap_Client::STATUS_HIGHESTMODSEQ);
if ($status_res['messages'] ||
in_array(Horde_Imap_Client::SEARCH_RESULTS_SAVE, $options['results'])) {
/* RFC 7162 [3.1.2.2] - trying to do a MODSEQ SEARCH on a mailbox
* that doesn't support it will return BAD. */
if (in_array('CONDSTORE', $squery['exts']) &&
!$this->_mailboxOb()->getStatus(Horde_Imap_Client::STATUS_HIGHESTMODSEQ)) {
throw new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("Mailbox does not support mod-sequences."),
Horde_Imap_Client_Exception::MBOXNOMODSEQ
);
}
$ret = $this->_search($query, $options);
} else {
$ret = $default_ret;
if (isset($status_res['highestmodseq'])) {
$ret['modseq'] = $status_res['highestmodseq'];
}
}
if ($cache) {
$save = $ret;
if (isset($save['match'])) {
$save['match'] = strval($ret['match']);
}
$this->_setSearchCache($save, $cache);
}
return $ret;
}
/**
* Search a mailbox.
*
* @param object $query The search query.
* @param array $options Additional options. The '_query' key contains
* the value of $query->build().
*
* @return Horde_Imap_Client_Ids An array of IDs.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _search($query, $options);
/**
* Set the comparator to use for searching/sorting (RFC 5255).
*
* @param string $comparator The comparator string (see RFC 4790 [3.1] -
* "collation-id" - for format). The reserved
* string 'default' can be used to select
* the default comparator.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function setComparator($comparator = null)
{
$comp = is_null($comparator)
? $this->getParam('comparator')
: $comparator;
if (is_null($comp)) {
return;
}
$this->login();
if (!$this->_capability('I18NLEVEL', '2')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension(
'I18NLEVEL',
'The IMAP server does not support changing SEARCH/SORT comparators.'
);
}
$this->_setComparator($comp);
}
/**
* Set the comparator to use for searching/sorting (RFC 5255).
*
* @param string $comparator The comparator string (see RFC 4790 [3.1] -
* "collation-id" - for format). The reserved
* string 'default' can be used to select
* the default comparator.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _setComparator($comparator);
/**
* Get the comparator used for searching/sorting (RFC 5255).
*
* @return mixed Null if the default comparator is being used, or an
* array of comparator information (see RFC 5255 [4.8]).
*
* @throws Horde_Imap_Client_Exception
*/
public function getComparator()
{
$this->login();
return $this->_capability('I18NLEVEL', '2')
? $this->_getComparator()
: null;
}
/**
* Get the comparator used for searching/sorting (RFC 5255).
*
* @return mixed Null if the default comparator is being used, or an
* array of comparator information (see RFC 5255 [4.8]).
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getComparator();
/**
* Thread sort a given list of messages (RFC 5256).
*
* @param mixed $mailbox The mailbox to query. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param array $options Additional options:
*
* - criteria: (mixed) The following thread criteria are available:
* - Horde_Imap_Client::THREAD_ORDEREDSUBJECT
* - Horde_Imap_Client::THREAD_REFERENCES
* - Horde_Imap_Client::THREAD_REFS
* Other algorithms can be explicitly specified by passing the IMAP
* thread algorithm in as a string value.
* DEFAULT: Horde_Imap_Client::THREAD_ORDEREDSUBJECT
* - search: (Horde_Imap_Client_Search_Query) The search query.
* DEFAULT: All messages in mailbox included in thread sort.
* - sequence: (boolean) If true, each message is stored and referred to
* by its message sequence number.
* DEFAULT: Stored/referred to by UID.
*
*
* @return Horde_Imap_Client_Data_Thread A thread data object.
*
* @throws Horde_Imap_Client_Exception
*/
public function thread($mailbox, array $options = array())
{
// Open mailbox call will handle the login.
$this->openMailbox($mailbox, Horde_Imap_Client::OPEN_AUTO);
/* Take advantage of search result caching. If CONDSTORE available,
* we can cache all queries and invalidate the cache when the MODSEQ
* changes. If CONDSTORE not available, we can only store queries
* that don't involve flags. See search() for similar caching. */
$cache = null;
if ($this->_initCache(true) &&
($this->_capability()->isEnabled('CONDSTORE') ||
empty($options['search']) ||
!$options['search']->flagSearch())) {
$cache = $this->_getSearchCache('thread', $options);
if (isset($cache['data']) &&
($cache['data'] instanceof Horde_Imap_Client_Data_Thread)) {
return $cache['data'];
}
}
$status_res = $this->status($this->_selected, Horde_Imap_Client::STATUS_MESSAGES);
$ob = $status_res['messages']
? $this->_thread($options)
: new Horde_Imap_Client_Data_Thread(array(), empty($options['sequence']) ? 'uid' : 'sequence');
if ($cache) {
$this->_setSearchCache($ob, $cache);
}
return $ob;
}
/**
* Thread sort a given list of messages (RFC 5256).
*
* @param array $options Additional options. See thread().
*
* @return Horde_Imap_Client_Data_Thread A thread data object.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _thread($options);
/**
* Fetch message data (see RFC 3501 [6.4.5]).
*
* @param mixed $mailbox The mailbox to search.
* Either a
* Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param Horde_Imap_Client_Fetch_Query $query Fetch query object.
* @param array $options Additional options:
* - changedsince: (integer) Only return messages that have a
* mod-sequence larger than this value. This option
* requires the CONDSTORE IMAP extension (if not present,
* this value is ignored). Additionally, the mailbox
* must support mod-sequences or an exception will be
* thrown. If valid, this option implicity adds the
* mod-sequence fetch criteria to the fetch command.
* DEFAULT: Mod-sequence values are ignored.
* - exists: (boolean) Ensure that all ids returned exist on the server.
* If false, the list of ids returned in the results object
* is not guaranteed to reflect the current state of the
* remote mailbox.
* DEFAULT: false
* - ids: (Horde_Imap_Client_Ids) A list of messages to fetch data from.
* DEFAULT: All messages in $mailbox will be fetched.
* - nocache: (boolean) If true, will not cache the results (previously
* cached data will still be used to generate results) [since
* 2.8.0].
* DEFAULT: false
*
* @return Horde_Imap_Client_Fetch_Results A results object.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function fetch($mailbox, $query, array $options = array())
{
try {
$ret = $this->_fetchWrapper($mailbox, $query, $options);
unset($this->_temp['fetch_nocache']);
return $ret;
} catch (Exception $e) {
unset($this->_temp['fetch_nocache']);
throw $e;
}
}
/**
* Wrapper for fetch() to allow internal state to be reset on exception.
*
* @internal
* @see fetch()
*/
private function _fetchWrapper($mailbox, $query, $options)
{
$this->login();
$query = clone $query;
$cache_array = $header_cache = $new_query = array();
if (empty($options['ids'])) {
$options['ids'] = $this->getIdsOb(Horde_Imap_Client_Ids::ALL);
} elseif ($options['ids']->isEmpty()) {
return new Horde_Imap_Client_Fetch_Results($this->_fetchDataClass);
} elseif ($options['ids']->search_res &&
!$this->_capability('SEARCHRES')) {
/* SEARCHRES requires server support. */
throw new Horde_Imap_Client_Exception_NoSupportExtension('SEARCHRES');
}
$this->openMailbox($mailbox, Horde_Imap_Client::OPEN_AUTO);
$mbox_ob = $this->_mailboxOb();
if (!empty($options['nocache'])) {
$this->_temp['fetch_nocache'] = true;
}
$cf = $this->_initCache(true)
? $this->_cacheFields()
: array();
if (!empty($cf)) {
/* If using cache, we store by UID so we need to return UIDs. */
$query->uid();
}
$modseq_check = !empty($options['changedsince']);
if ($query->contains(Horde_Imap_Client::FETCH_MODSEQ)) {
if (!$this->_capability()->isEnabled('CONDSTORE')) {
unset($query[Horde_Imap_Client::FETCH_MODSEQ]);
} elseif (empty($options['changedsince'])) {
$modseq_check = true;
}
}
if ($modseq_check &&
!$mbox_ob->getStatus(Horde_Imap_Client::STATUS_HIGHESTMODSEQ)) {
/* RFC 7162 [3.1.2.2] - trying to do a MODSEQ FETCH on a mailbox
* that doesn't support it will return BAD. */
throw new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("Mailbox does not support mod-sequences."),
Horde_Imap_Client_Exception::MBOXNOMODSEQ
);
}
/* Determine if caching is available and if anything in $query is
* cacheable. */
foreach ($cf as $k => $v) {
if (isset($query[$k])) {
switch ($k) {
case Horde_Imap_Client::FETCH_ENVELOPE:
case Horde_Imap_Client::FETCH_FLAGS:
case Horde_Imap_Client::FETCH_IMAPDATE:
case Horde_Imap_Client::FETCH_SIZE:
case Horde_Imap_Client::FETCH_STRUCTURE:
$cache_array[$k] = $v;
break;
case Horde_Imap_Client::FETCH_HEADERS:
$this->_temp['headers_caching'] = array();
foreach ($query[$k] as $key => $val) {
/* Only cache if directly requested. Iterate through
* requests to ensure at least one can be cached. */
if (!empty($val['cache']) && !empty($val['peek'])) {
$cache_array[$k] = $v;
ksort($val);
$header_cache[$key] = hash('md5', serialize($val));
}
}
break;
}
}
}
$ret = new Horde_Imap_Client_Fetch_Results(
$this->_fetchDataClass,
$options['ids']->sequence ? Horde_Imap_Client_Fetch_Results::SEQUENCE : Horde_Imap_Client_Fetch_Results::UID
);
/* If nothing is cacheable, we can do a straight search. */
if (empty($cache_array)) {
$options['_query'] = $query;
$this->_fetch($ret, array($options));
return $ret;
}
$cs_ret = empty($options['changedsince'])
? null
: clone $ret;
/* Convert special searches to UID lists and create mapping. */
$ids = $this->resolveIds(
$this->_selected,
$options['ids'],
empty($options['exists']) ? 1 : 2
);
/* Add non-user settable cache fields. */
$cache_array[Horde_Imap_Client::FETCH_DOWNGRADED] = self::CACHE_DOWNGRADED;
/* Get the cached values. */
$data = $this->_cache->get(
$this->_selected,
$ids->ids,
array_values($cache_array),
$mbox_ob->getStatus(Horde_Imap_Client::STATUS_UIDVALIDITY)
);
/* Build a list of what we still need. */
$map = array_flip($mbox_ob->map->map);
$sequence = $options['ids']->sequence;
foreach ($ids as $uid) {
$crit = clone $query;
if ($sequence) {
if (!isset($map[$uid])) {
continue;
}
$entry_idx = $map[$uid];
} else {
$entry_idx = $uid;
unset($crit[Horde_Imap_Client::FETCH_UID]);
}
$entry = $ret->get($entry_idx);
if (isset($map[$uid])) {
$entry->setSeq($map[$uid]);
unset($crit[Horde_Imap_Client::FETCH_SEQ]);
}
$entry->setUid($uid);
foreach ($cache_array as $key => $cid) {
switch ($key) {
case Horde_Imap_Client::FETCH_DOWNGRADED:
if (!empty($data[$uid][$cid])) {
$entry->setDowngraded(true);
}
break;
case Horde_Imap_Client::FETCH_ENVELOPE:
if (isset($data[$uid][$cid]) &&
($data[$uid][$cid] instanceof Horde_Imap_Client_Data_Envelope)) {
$entry->setEnvelope($data[$uid][$cid]);
unset($crit[$key]);
}
break;
case Horde_Imap_Client::FETCH_FLAGS:
if (isset($data[$uid][$cid]) &&
is_array($data[$uid][$cid])) {
$entry->setFlags($data[$uid][$cid]);
unset($crit[$key]);
}
break;
case Horde_Imap_Client::FETCH_HEADERS:
foreach ($header_cache as $hkey => $hval) {
if (isset($data[$uid][$cid][$hval])) {
/* We have found a cached entry with the same
* MD5 sum. */
$entry->setHeaders($hkey, $data[$uid][$cid][$hval]);
$crit->remove($key, $hkey);
} else {
$this->_temp['headers_caching'][$hkey] = $hval;
}
}
break;
case Horde_Imap_Client::FETCH_IMAPDATE:
if (isset($data[$uid][$cid]) &&
($data[$uid][$cid] instanceof Horde_Imap_Client_DateTime)) {
$entry->setImapDate($data[$uid][$cid]);
unset($crit[$key]);
}
break;
case Horde_Imap_Client::FETCH_SIZE:
if (isset($data[$uid][$cid])) {
$entry->setSize($data[$uid][$cid]);
unset($crit[$key]);
}
break;
case Horde_Imap_Client::FETCH_STRUCTURE:
if (isset($data[$uid][$cid]) &&
($data[$uid][$cid] instanceof Horde_Mime_Part)) {
$entry->setStructure($data[$uid][$cid]);
unset($crit[$key]);
}
break;
}
}
if (count($crit)) {
$sig = $crit->hash();
if (isset($new_query[$sig])) {
$new_query[$sig]['i'][] = $entry_idx;
} else {
$new_query[$sig] = array(
'c' => $crit,
'i' => array($entry_idx)
);
}
}
}
$to_fetch = array();
foreach ($new_query as $val) {
$ids_ob = $this->getIdsOb(null, $sequence);
$ids_ob->duplicates = true;
$ids_ob->add($val['i']);
$to_fetch[] = array_merge($options, array(
'_query' => $val['c'],
'ids' => $ids_ob
));
}
if (!empty($to_fetch)) {
$this->_fetch(is_null($cs_ret) ? $ret : $cs_ret, $to_fetch);
}
if (is_null($cs_ret)) {
return $ret;
}
/* If doing changedsince query, and all other data is cached, we still
* need to hit IMAP server to determine proper results set. */
if (empty($new_query)) {
$squery = new Horde_Imap_Client_Search_Query();
$squery->modseq($options['changedsince'] + 1);
$squery->ids($options['ids']);
$cs = $this->search($this->_selected, $squery, array(
'sequence' => $sequence
));
foreach ($cs['match'] as $val) {
$entry = $ret->get($val);
if ($sequence) {
$entry->setSeq($val);
} else {
$entry->setUid($val);
}
$cs_ret[$val] = $entry;
}
} else {
foreach ($cs_ret as $key => $val) {
$val->merge($ret->get($key));
}
}
return $cs_ret;
}
/**
* Fetch message data.
*
* Fetch queries should be grouped in the $queries argument. Each value
* is an array of fetch options, with the fetch query stored in the
* '_query' parameter. IMPORTANT: All queries must have the same ID
* type (either sequence or UID).
*
* @param Horde_Imap_Client_Fetch_Results $results Fetch results.
* @param array $queries The list of queries.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _fetch(Horde_Imap_Client_Fetch_Results $results,
$queries);
/**
* Get the list of vanished messages (UIDs that have been expunged since a
* given mod-sequence value).
*
* @param mixed $mailbox The mailbox to query. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param integer $modseq Search for expunged messages after this
* mod-sequence value.
* @param array $opts Additional options:
* - ids: (Horde_Imap_Client_Ids) Restrict to these UIDs.
* DEFAULT: Returns full list of UIDs vanished (QRESYNC only).
* This option is REQUIRED for non-QRESYNC servers or
* else an empty list will be returned.
*
* @return Horde_Imap_Client_Ids List of UIDs that have vanished.
*
* @throws Horde_Imap_Client_NoSupportExtension
*/
public function vanished($mailbox, $modseq, array $opts = array())
{
$this->login();
if (empty($opts['ids'])) {
if (!$this->_capability()->isEnabled('QRESYNC')) {
return $this->getIdsOb();
}
$opts['ids'] = $this->getIdsOb(Horde_Imap_Client_Ids::ALL);
} elseif ($opts['ids']->isEmpty()) {
return $this->getIdsOb();
} elseif ($opts['ids']->sequence) {
throw new InvalidArgumentException('Vanished requires UIDs.');
}
$this->openMailbox($mailbox, Horde_Imap_Client::OPEN_AUTO);
if ($this->_capability()->isEnabled('QRESYNC')) {
if (!$this->_mailboxOb()->getStatus(Horde_Imap_Client::STATUS_HIGHESTMODSEQ)) {
throw new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("Mailbox does not support mod-sequences."),
Horde_Imap_Client_Exception::MBOXNOMODSEQ
);
}
return $this->_vanished(max(1, $modseq), $opts['ids']);
}
$ids = $this->resolveIds($mailbox, $opts['ids']);
$squery = new Horde_Imap_Client_Search_Query();
$squery->ids($ids);
$search = $this->search($mailbox, $squery, array(
'nocache' => true
));
return $this->getIdsOb(array_diff($ids->ids, $search['match']->ids));
}
/**
* Get the list of vanished messages.
*
* @param integer $modseq Mod-sequence value.
* @param Horde_Imap_Client_Ids $ids UIDs.
*
* @return Horde_Imap_Client_Ids List of UIDs that have vanished.
*/
abstract protected function _vanished($modseq, Horde_Imap_Client_Ids $ids);
/**
* Store message flag data (see RFC 3501 [6.4.6]).
*
* @param mixed $mailbox The mailbox containing the messages to modify.
* Either a Horde_Imap_Client_Mailbox object or a
* string (UTF-8).
* @param array $options Additional options:
* - add: (array) An array of flags to add.
* DEFAULT: No flags added.
* - ids: (Horde_Imap_Client_Ids) The list of messages to modify.
* DEFAULT: All messages in $mailbox will be modified.
* - remove: (array) An array of flags to remove.
* DEFAULT: No flags removed.
* - replace: (array) Replace the current flags with this set
* of flags. Overrides both the 'add' and 'remove' options.
* DEFAULT: No replace is performed.
* - unchangedsince: (integer) Only changes flags if the mod-sequence ID
* of the message is equal or less than this value.
* Requires the CONDSTORE IMAP extension on the server.
* Also requires the mailbox to support mod-sequences.
* Will throw an exception if either condition is not
* met.
* DEFAULT: mod-sequence is ignored when applying
* changes
*
* @return Horde_Imap_Client_Ids A Horde_Imap_Client_Ids object
* containing the list of IDs that failed
* the 'unchangedsince' test.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function store($mailbox, array $options = array())
{
// Open mailbox call will handle the login.
$this->openMailbox($mailbox, Horde_Imap_Client::OPEN_READWRITE);
/* SEARCHRES requires server support. */
if (empty($options['ids'])) {
$options['ids'] = $this->getIdsOb(Horde_Imap_Client_Ids::ALL);
} elseif ($options['ids']->isEmpty()) {
return $this->getIdsOb();
} elseif ($options['ids']->search_res &&
!$this->_capability('SEARCHRES')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('SEARCHRES');
}
if (!empty($options['unchangedsince'])) {
if (!$this->_capability()->isEnabled('CONDSTORE')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('CONDSTORE');
}
/* RFC 7162 [3.1.2.2] - trying to do a UNCHANGEDSINCE STORE on a
* mailbox that doesn't support it will return BAD. */
if (!$this->_mailboxOb()->getStatus(Horde_Imap_Client::STATUS_HIGHESTMODSEQ)) {
throw new Horde_Imap_Client_Exception(
Horde_Imap_Client_Translation::r("Mailbox does not support mod-sequences."),
Horde_Imap_Client_Exception::MBOXNOMODSEQ
);
}
}
return $this->_store($options);
}
/**
* Store message flag data.
*
* @param array $options Additional options.
*
* @return Horde_Imap_Client_Ids A Horde_Imap_Client_Ids object
* containing the list of IDs that failed
* the 'unchangedsince' test.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _store($options);
/**
* Copy messages to another mailbox.
*
* @param mixed $source The source mailbox. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param mixed $dest The destination mailbox. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param array $options Additional options:
* - create: (boolean) Try to create $dest if it does not exist?
* DEFAULT: No.
* - force_map: (boolean) Forces the array mapping to always be
* returned. [@since 2.19.0]
* - ids: (Horde_Imap_Client_Ids) The list of messages to copy.
* DEFAULT: All messages in $mailbox will be copied.
* - move: (boolean) If true, delete the original messages.
* DEFAULT: Original messages are not deleted.
*
* @return mixed An array mapping old UIDs (keys) to new UIDs (values) on
* success (only guaranteed if 'force_map' is true) or
* true.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function copy($source, $dest, array $options = array())
{
// Open mailbox call will handle the login.
$this->openMailbox($source, empty($options['move']) ? Horde_Imap_Client::OPEN_AUTO : Horde_Imap_Client::OPEN_READWRITE);
/* SEARCHRES requires server support. */
if (empty($options['ids'])) {
$options['ids'] = $this->getIdsOb(Horde_Imap_Client_Ids::ALL);
} elseif ($options['ids']->isEmpty()) {
return array();
} elseif ($options['ids']->search_res &&
!$this->_capability('SEARCHRES')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('SEARCHRES');
}
$dest = Horde_Imap_Client_Mailbox::get($dest);
$res = $this->_copy($dest, $options);
if (($res === true) && !empty($options['force_map'])) {
/* Need to manually create mapping from Message-ID data. */
$query = new Horde_Imap_Client_Fetch_Query();
$query->envelope();
$fetch = $this->fetch($source, $query, array(
'ids' => $options['ids']
));
$res = array();
foreach ($fetch as $val) {
if ($uid = $this->_getUidByMessageId($dest, $val->getEnvelope()->message_id)) {
$res[$val->getUid()] = $uid;
}
}
}
return $res;
}
/**
* Copy messages to another mailbox.
*
* @param Horde_Imap_Client_Mailbox $dest The destination mailbox.
* @param array $options Additional options.
*
* @return mixed An array mapping old UIDs (keys) to new UIDs (values) on
* success (if the IMAP server and/or driver support the
* UIDPLUS extension) or true.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _copy(Horde_Imap_Client_Mailbox $dest,
$options);
/**
* Set quota limits. The server must support the IMAP QUOTA extension
* (RFC 2087).
*
* @param mixed $root The quota root. Either a
* Horde_Imap_Client_Mailbox object or a string
* (UTF-8).
* @param array $resources The resource values to set. Keys are the
* resource atom name; value is the resource
* value.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function setQuota($root, array $resources = array())
{
$this->login();
if (!$this->_capability('QUOTA')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('QUOTA');
}
if (!empty($resources)) {
$this->_setQuota(Horde_Imap_Client_Mailbox::get($root), $resources);
}
}
/**
* Set quota limits.
*
* @param Horde_Imap_Client_Mailbox $root The quota root.
* @param array $resources The resource values to set.
*
* @return boolean True on success.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _setQuota(Horde_Imap_Client_Mailbox $root,
$resources);
/**
* Get quota limits. The server must support the IMAP QUOTA extension
* (RFC 2087).
*
* @param mixed $root The quota root. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
*
* @return mixed An array with resource keys. Each key holds an array
* with 2 values: 'limit' and 'usage'.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function getQuota($root)
{
$this->login();
if (!$this->_capability('QUOTA')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('QUOTA');
}
return $this->_getQuota(Horde_Imap_Client_Mailbox::get($root));
}
/**
* Get quota limits.
*
* @param Horde_Imap_Client_Mailbox $root The quota root.
*
* @return mixed An array with resource keys. Each key holds an array
* with 2 values: 'limit' and 'usage'.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getQuota(Horde_Imap_Client_Mailbox $root);
/**
* Get quota limits for a mailbox. The server must support the IMAP QUOTA
* extension (RFC 2087).
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
*
* @return mixed An array with the keys being the quota roots. Each key
* holds an array with resource keys: each of these keys
* holds an array with 2 values: 'limit' and 'usage'.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function getQuotaRoot($mailbox)
{
$this->login();
if (!$this->_capability('QUOTA')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('QUOTA');
}
return $this->_getQuotaRoot(Horde_Imap_Client_Mailbox::get($mailbox));
}
/**
* Get quota limits for a mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
*
* @return mixed An array with the keys being the quota roots. Each key
* holds an array with resource keys: each of these keys
* holds an array with 2 values: 'limit' and 'usage'.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getQuotaRoot(Horde_Imap_Client_Mailbox $mailbox);
/**
* Get the ACL rights for a given mailbox. The server must support the
* IMAP ACL extension (RFC 2086/4314).
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
*
* @return array An array with identifiers as the keys and
* Horde_Imap_Client_Data_Acl objects as the values.
*
* @throws Horde_Imap_Client_Exception
*/
public function getACL($mailbox)
{
$this->login();
return $this->_getACL(Horde_Imap_Client_Mailbox::get($mailbox));
}
/**
* Get ACL rights for a given mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
*
* @return array An array with identifiers as the keys and
* Horde_Imap_Client_Data_Acl objects as the values.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getACL(Horde_Imap_Client_Mailbox $mailbox);
/**
* Set ACL rights for a given mailbox/identifier.
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param string $identifier The identifier to alter (UTF-8).
* @param array $options Additional options:
* - rights: (string) The rights to alter or set.
* - action: (string, optional) If 'add' or 'remove', adds or removes the
* specified rights. Sets the rights otherwise.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function setACL($mailbox, $identifier, $options)
{
$this->login();
if (!$this->_capability('ACL')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('ACL');
}
if (empty($options['rights'])) {
if (!isset($options['action']) ||
(($options['action'] != 'add') &&
$options['action'] != 'remove')) {
$this->_deleteACL(
Horde_Imap_Client_Mailbox::get($mailbox),
Horde_Imap_Client_Utf7imap::Utf8ToUtf7Imap($identifier)
);
}
return;
}
$acl = ($options['rights'] instanceof Horde_Imap_Client_Data_Acl)
? $options['rights']
: new Horde_Imap_Client_Data_Acl(strval($options['rights']));
$options['rights'] = $acl->getString(
$this->_capability('RIGHTS')
? Horde_Imap_Client_Data_AclCommon::RFC_4314
: Horde_Imap_Client_Data_AclCommon::RFC_2086
);
if (isset($options['action'])) {
switch ($options['action']) {
case 'add':
$options['rights'] = '+' . $options['rights'];
break;
case 'remove':
$options['rights'] = '-' . $options['rights'];
break;
}
}
$this->_setACL(
Horde_Imap_Client_Mailbox::get($mailbox),
Horde_Imap_Client_Utf7imap::Utf8ToUtf7Imap($identifier),
$options
);
}
/**
* Set ACL rights for a given mailbox/identifier.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
* @param string $identifier The identifier to alter
* (UTF7-IMAP).
* @param array $options Additional options. 'rights'
* contains the string of
* rights to set on the server.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _setACL(Horde_Imap_Client_Mailbox $mailbox,
$identifier, $options);
/**
* Deletes ACL rights for a given mailbox/identifier.
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param string $identifier The identifier to delete (UTF-8).
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function deleteACL($mailbox, $identifier)
{
$this->login();
if (!$this->_capability('ACL')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('ACL');
}
$this->_deleteACL(
Horde_Imap_Client_Mailbox::get($mailbox),
Horde_Imap_Client_Utf7imap::Utf8ToUtf7Imap($identifier)
);
}
/**
* Deletes ACL rights for a given mailbox/identifier.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
* @param string $identifier The identifier to delete
* (UTF7-IMAP).
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _deleteACL(Horde_Imap_Client_Mailbox $mailbox,
$identifier);
/**
* List the ACL rights for a given mailbox/identifier. The server must
* support the IMAP ACL extension (RFC 2086/4314).
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param string $identifier The identifier to query (UTF-8).
*
* @return Horde_Imap_Client_Data_AclRights An ACL data rights object.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function listACLRights($mailbox, $identifier)
{
$this->login();
if (!$this->_capability('ACL')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('ACL');
}
return $this->_listACLRights(
Horde_Imap_Client_Mailbox::get($mailbox),
Horde_Imap_Client_Utf7imap::Utf8ToUtf7Imap($identifier)
);
}
/**
* Get ACL rights for a given mailbox/identifier.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
* @param string $identifier The identifier to query
* (UTF7-IMAP).
*
* @return Horde_Imap_Client_Data_AclRights An ACL data rights object.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _listACLRights(Horde_Imap_Client_Mailbox $mailbox,
$identifier);
/**
* Get the ACL rights for the current user for a given mailbox. The
* server must support the IMAP ACL extension (RFC 2086/4314).
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
*
* @return Horde_Imap_Client_Data_Acl An ACL data object.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_NoSupportExtension
*/
public function getMyACLRights($mailbox)
{
$this->login();
if (!$this->_capability('ACL')) {
throw new Horde_Imap_Client_Exception_NoSupportExtension('ACL');
}
return $this->_getMyACLRights(Horde_Imap_Client_Mailbox::get($mailbox));
}
/**
* Get the ACL rights for the current user for a given mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
*
* @return Horde_Imap_Client_Data_Acl An ACL data object.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getMyACLRights(Horde_Imap_Client_Mailbox $mailbox);
/**
* Return master list of ACL rights available on the server.
*
* @return array A list of ACL rights.
*/
public function allAclRights()
{
$this->login();
$rights = array(
Horde_Imap_Client::ACL_LOOKUP,
Horde_Imap_Client::ACL_READ,
Horde_Imap_Client::ACL_SEEN,
Horde_Imap_Client::ACL_WRITE,
Horde_Imap_Client::ACL_INSERT,
Horde_Imap_Client::ACL_POST,
Horde_Imap_Client::ACL_ADMINISTER
);
if ($capability = $this->_capability()->getParams('RIGHTS')) {
// Add rights defined in CAPABILITY string (RFC 4314).
return array_merge($rights, str_split(reset($capability)));
}
// Add RFC 2086 rights (deprecated by RFC 4314, but need to keep for
// compatibility with old servers).
return array_merge($rights, array(
Horde_Imap_Client::ACL_CREATE,
Horde_Imap_Client::ACL_DELETE
));
}
/**
* Get metadata for a given mailbox. The server must support either the
* IMAP METADATA extension (RFC 5464) or the ANNOTATEMORE extension
* (http://ietfreport.isoc.org/idref/draft-daboo-imap-annotatemore/).
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param array $entries The entries to fetch (UTF-8 strings).
* @param array $options Additional options:
* - depth: (string) Either "0", "1" or "infinity". Returns only the
* given value (0), only values one level below the specified
* value (1) or all entries below the specified value
* (infinity).
* - maxsize: (integer) The maximal size the returned values may have.
* DEFAULT: No maximal size.
*
* @return array An array with metadata names as the keys and metadata
* values as the values. If 'maxsize' is set, and entries
* exist on the server larger than this size, the size will
* be returned in the key '*longentries'.
*
* @throws Horde_Imap_Client_Exception
*/
public function getMetadata($mailbox, $entries, array $options = array())
{
$this->login();
if (!is_array($entries)) {
$entries = array($entries);
}
return $this->_getMetadata(Horde_Imap_Client_Mailbox::get($mailbox), array_map(array('Horde_Imap_Client_Utf7imap', 'Utf8ToUtf7Imap'), $entries), $options);
}
/**
* Get metadata for a given mailbox.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
* @param array $entries The entries to fetch
* (UTF7-IMAP strings).
* @param array $options Additional options.
*
* @return array An array with metadata names as the keys and metadata
* values as the values.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _getMetadata(Horde_Imap_Client_Mailbox $mailbox,
$entries, $options);
/**
* Set metadata for a given mailbox/identifier.
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8). If empty, sets a
* server annotation.
* @param array $data A set of data values. The metadata values
* corresponding to the keys of the array will
* be set to the values in the array.
*
* @throws Horde_Imap_Client_Exception
*/
public function setMetadata($mailbox, $data)
{
$this->login();
$this->_setMetadata(Horde_Imap_Client_Mailbox::get($mailbox), $data);
}
/**
* Set metadata for a given mailbox/identifier.
*
* @param Horde_Imap_Client_Mailbox $mailbox A mailbox.
* @param array $data A set of data values. See
* setMetadata() for format.
*
* @throws Horde_Imap_Client_Exception
*/
abstract protected function _setMetadata(Horde_Imap_Client_Mailbox $mailbox,
$data);
/* Public utility functions. */
/**
* Returns a unique identifier for the current mailbox status.
*
* @deprecated
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param array $addl Additional cache info to add to the cache ID
* string.
*
* @return string The cache ID string, which will change when the
* composition of the mailbox changes. The uidvalidity
* will always be the first element, and will be delimited
* by the '|' character.
*
* @throws Horde_Imap_Client_Exception
*/
public function getCacheId($mailbox, array $addl = array())
{
return Horde_Imap_Client_Base_Deprecated::getCacheId($this, $mailbox, $this->_capability()->isEnabled('CONDSTORE'), $addl);
}
/**
* Parses a cacheID created by getCacheId().
*
* @deprecated
*
* @param string $id The cache ID.
*
* @return array An array with the following information:
* - highestmodseq: (integer)
* - messages: (integer)
* - uidnext: (integer)
* - uidvalidity: (integer) Always present
*/
public function parseCacheId($id)
{
return Horde_Imap_Client_Base_Deprecated::parseCacheId($id);
}
/**
* Resolves an IDs object into a list of IDs.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox.
* @param Horde_Imap_Client_Ids $ids The Ids object.
* @param integer $convert Convert to UIDs?
* - 0: No
* - 1: Only if $ids is not already a UIDs object
* - 2: Always
*
* @return Horde_Imap_Client_Ids The list of IDs.
*/
public function resolveIds(Horde_Imap_Client_Mailbox $mailbox,
Horde_Imap_Client_Ids $ids, $convert = 0)
{
$map = $this->_mailboxOb($mailbox)->map;
if ($ids->special) {
/* Optimization for ALL sequence searches. */
if (!$convert && $ids->all && $ids->sequence) {
$res = $this->status($mailbox, Horde_Imap_Client::STATUS_MESSAGES);
return $this->getIdsOb($res['messages'] ? ('1:' . $res['messages']) : array(), true);
}
$convert = 2;
} elseif (!$convert ||
(!$ids->sequence && ($convert == 1)) ||
$ids->isEmpty()) {
return clone $ids;
} else {
/* Do an all or nothing: either we have all the numbers/UIDs in
* memory and can return, or just send the whole ID query to the
* server. Any advantage we would get by a partial search are
* outweighed by the complexities needed to make the search and
* then merge back into the original results. */
$lookup = $map->lookup($ids);
if (count($lookup) === count($ids)) {
return $this->getIdsOb(array_values($lookup));
}
}
$query = new Horde_Imap_Client_Search_Query();
$query->ids($ids);
$res = $this->search($mailbox, $query, array(
'results' => array(
Horde_Imap_Client::SEARCH_RESULTS_MATCH,
Horde_Imap_Client::SEARCH_RESULTS_SAVE
),
'sequence' => (!$convert && $ids->sequence),
'sort' => array(Horde_Imap_Client::SORT_SEQUENCE)
));
/* Update mapping. */
if ($convert) {
if ($ids->all) {
$ids = $this->getIdsOb('1:' . count($res['match']));
} elseif ($ids->special) {
return $res['match'];
}
/* Sanity checking (Bug #12911). */
$list1 = array_slice($ids->ids, 0, count($res['match']));
$list2 = $res['match']->ids;
if (!empty($list1) &&
!empty($list2) &&
(count($list1) === count($list2))) {
$map->update(array_combine($list1, $list2));
}
}
return $res['match'];
}
/**
* Determines if the given charset is valid for search-related queries.
* This check pertains just to the basic IMAP SEARCH command.
*
* @deprecated Use $search_charset property instead.
*
* @param string $charset The query charset.
*
* @return boolean True if server supports this charset.
*/
public function validSearchCharset($charset)
{
return $this->search_charset->query($charset);
}
/* Mailbox syncing functions. */
/**
* Returns a unique token for the current mailbox synchronization status.
*
* @since 2.2.0
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
*
* @return string The sync token.
*
* @throws Horde_Imap_Client_Exception
*/
public function getSyncToken($mailbox)
{
$out = array();
foreach ($this->_syncStatus($mailbox) as $key => $val) {
$out[] = $key . $val;
}
return base64_encode(implode(',', $out));
}
/**
* Synchronize a mailbox from a sync token.
*
* @since 2.2.0
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
* @param string $token A sync token generated by getSyncToken().
* @param array $opts Additional options:
* - criteria: (integer) Mask of Horde_Imap_Client::SYNC_* criteria to
* return. Defaults to SYNC_ALL.
* - ids: (Horde_Imap_Client_Ids) A cached list of UIDs. Unless QRESYNC
* is available on the server, failure to specify this option
* means SYNC_VANISHEDUIDS information cannot be returned.
*
* @return Horde_Imap_Client_Data_Sync A sync object.
*
* @throws Horde_Imap_Client_Exception
* @throws Horde_Imap_Client_Exception_Sync
*/
public function sync($mailbox, $token, array $opts = array())
{
if (($token = base64_decode($token, true)) === false) {
throw new Horde_Imap_Client_Exception_Sync('Bad token.', Horde_Imap_Client_Exception_Sync::BAD_TOKEN);
}
$sync = array();
foreach (explode(',', $token) as $val) {
$sync[substr($val, 0, 1)] = substr($val, 1);
}
return new Horde_Imap_Client_Data_Sync(
$this,
$mailbox,
$sync,
$this->_syncStatus($mailbox),
(isset($opts['criteria']) ? $opts['criteria'] : Horde_Imap_Client::SYNC_ALL),
(isset($opts['ids']) ? $opts['ids'] : null)
);
}
/* Private utility functions. */
/**
* Store FETCH data in cache.
*
* @param Horde_Imap_Client_Fetch_Results $data The fetch results.
*
* @throws Horde_Imap_Client_Exception
*/
protected function _updateCache(Horde_Imap_Client_Fetch_Results $data)
{
if (!empty($this->_temp['fetch_nocache']) ||
empty($this->_selected) ||
!count($data) ||
!$this->_initCache(true)) {
return;
}
$c = $this->getParam('cache');
if (in_array(strval($this->_selected), $c['fetch_ignore'])) {
$this->_debug->info(sprintf(
'CACHE: Ignoring FETCH data [%s]',
$this->_selected
));
return;
}
/* Optimization: we can directly use getStatus() here since we know
* these values are initialized. */
$mbox_ob = $this->_mailboxOb();
$highestmodseq = $mbox_ob->getStatus(Horde_Imap_Client::STATUS_HIGHESTMODSEQ);
$uidvalidity = $mbox_ob->getStatus(Horde_Imap_Client::STATUS_UIDVALIDITY);
$mapping = $modseq = $tocache = array();
if (count($data)) {
$cf = $this->_cacheFields();
}
foreach ($data as $v) {
/* It is possible that we received FETCH information that doesn't
* contain UID data. This is uncacheable so don't process. */
if (!($uid = $v->getUid())) {
return;
}
$tmp = array();
if ($v->isDowngraded()) {
$tmp[self::CACHE_DOWNGRADED] = true;
}
foreach ($cf as $key => $val) {
if ($v->exists($key)) {
switch ($key) {
case Horde_Imap_Client::FETCH_ENVELOPE:
$tmp[$val] = $v->getEnvelope();
break;
case Horde_Imap_Client::FETCH_FLAGS:
if ($highestmodseq) {
$modseq[$uid] = $v->getModSeq();
$tmp[$val] = $v->getFlags();
}
break;
case Horde_Imap_Client::FETCH_HEADERS:
foreach ($this->_temp['headers_caching'] as $label => $hash) {
if ($hdr = $v->getHeaders($label)) {
$tmp[$val][$hash] = $hdr;
}
}
break;
case Horde_Imap_Client::FETCH_IMAPDATE:
$tmp[$val] = $v->getImapDate();
break;
case Horde_Imap_Client::FETCH_SIZE:
$tmp[$val] = $v->getSize();
break;
case Horde_Imap_Client::FETCH_STRUCTURE:
$tmp[$val] = clone $v->getStructure();
break;
}
}
}
if (!empty($tmp)) {
$tocache[$uid] = $tmp;
}
$mapping[$v->getSeq()] = $uid;
}
if (!empty($mapping)) {
if (!empty($tocache)) {
$this->_cache->set($this->_selected, $tocache, $uidvalidity);
}
$this->_mailboxOb()->map->update($mapping);
}
if (!empty($modseq)) {
$this->_updateModSeq(max(array_merge($modseq, array($highestmodseq))));
$mbox_ob->setStatus(Horde_Imap_Client::STATUS_SYNCFLAGUIDS, array_keys($modseq));
}
}
/**
* Moves cache entries from the current mailbox to another mailbox.
*
* @param Horde_Imap_Client_Mailbox $to The destination mailbox.
* @param array $map Mapping of source UIDs (keys) to
* destination UIDs (values).
* @param string $uidvalid UIDVALIDITY of destination
* mailbox.
*
* @throws Horde_Imap_Client_Exception
*/
protected function _moveCache(Horde_Imap_Client_Mailbox $to, $map,
$uidvalid)
{
if (!$this->_initCache()) {
return;
}
$c = $this->getParam('cache');
if (in_array(strval($to), $c['fetch_ignore'])) {
$this->_debug->info(sprintf(
'CACHE: Ignoring moving FETCH data (%s => %s)',
$this->_selected,
$to
));
return;
}
$old = $this->_cache->get($this->_selected, array_keys($map), null);
$new = array();
foreach ($map as $key => $val) {
if (!empty($old[$key])) {
$new[$val] = $old[$key];
}
}
if (!empty($new)) {
$this->_cache->set($to, $new, $uidvalid);
}
}
/**
* Delete messages in the cache.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox.
* @param Horde_Imap_Client_Ids $ids The list of IDs to delete in
* $mailbox.
* @param array $opts Additional options (not used
* in base class).
*
* @return Horde_Imap_Client_Ids UIDs that were deleted.
* @throws Horde_Imap_Client_Exception
*/
protected function _deleteMsgs(Horde_Imap_Client_Mailbox $mailbox,
Horde_Imap_Client_Ids $ids,
array $opts = array())
{
if (!$this->_initCache()) {
return $ids;
}
$mbox_ob = $this->_mailboxOb();
$ids_ob = $ids->sequence
? $this->getIdsOb($mbox_ob->map->lookup($ids))
: $ids;
$this->_cache->deleteMsgs($mailbox, $ids_ob->ids);
$mbox_ob->setStatus(Horde_Imap_Client::STATUS_SYNCVANISHED, $ids_ob->ids);
$mbox_ob->map->remove($ids);
return $ids_ob;
}
/**
* Retrieve data from the search cache.
*
* @param string $type The cache type ('search' or 'thread').
* @param array $options The options array of the calling function.
*
* @return mixed Returns search cache metadata. If search was retrieved,
* data is in key 'data'.
* Returns null if caching is not available.
*/
protected function _getSearchCache($type, $options)
{
$status = $this->status($this->_selected, Horde_Imap_Client::STATUS_HIGHESTMODSEQ | Horde_Imap_Client::STATUS_UIDVALIDITY);
/* Search caching requires MODSEQ, which may not be active for a
* mailbox. */
if (empty($status['highestmodseq'])) {
return null;
}
ksort($options);
$cache = hash('md5', $type . serialize($options));
$cacheid = $this->getSyncToken($this->_selected);
$ret = array();
$md = $this->_cache->getMetaData(
$this->_selected,
$status['uidvalidity'],
array(self::CACHE_SEARCH, self::CACHE_SEARCHID)
);
if (!isset($md[self::CACHE_SEARCHID]) ||
($md[self::CACHE_SEARCHID] != $cacheid)) {
$md[self::CACHE_SEARCH] = array();
$md[self::CACHE_SEARCHID] = $cacheid;
if ($this->_debug->debug &&
!isset($this->_temp['searchcacheexpire'][strval($this->_selected)])) {
$this->_debug->info(sprintf(
'SEARCH: Expired from cache [%s]',
$this->_selected
));
$this->_temp['searchcacheexpire'][strval($this->_selected)] = true;
}
} elseif (isset($md[self::CACHE_SEARCH][$cache])) {
$this->_debug->info(sprintf(
'SEARCH: Retrieved %s from cache (%s [%s])',
$type,
$cache,
$this->_selected
));
$ret['data'] = $md[self::CACHE_SEARCH][$cache];
unset($md[self::CACHE_SEARCHID]);
}
return array_merge($ret, array(
'id' => $cache,
'metadata' => $md,
'type' => $type
));
}
/**
* Set data in the search cache.
*
* @param mixed $data The cache data to store.
* @param string $sdata The search data returned from _getSearchCache().
*/
protected function _setSearchCache($data, $sdata)
{
$sdata['metadata'][self::CACHE_SEARCH][$sdata['id']] = $data;
$this->_cache->setMetaData($this->_selected, null, $sdata['metadata']);
if ($this->_debug->debug) {
$this->_debug->info(sprintf(
'SEARCH: Saved %s to cache (%s [%s])',
$sdata['type'],
$sdata['id'],
$this->_selected
));
unset($this->_temp['searchcacheexpire'][strval($this->_selected)]);
}
}
/**
* Updates the cached MODSEQ value.
*
* @param integer $modseq MODSEQ value to store.
*
* @return mixed The MODSEQ of the old value if it was replaced (or false
* if it didn't exist or is the same).
*/
protected function _updateModSeq($modseq)
{
if (!$this->_initCache(true)) {
return false;
}
$mbox_ob = $this->_mailboxOb();
$uidvalid = $mbox_ob->getStatus(Horde_Imap_Client::STATUS_UIDVALIDITY);
$md = $this->_cache->getMetaData($this->_selected, $uidvalid, array(self::CACHE_MODSEQ));
if (isset($md[self::CACHE_MODSEQ])) {
if ($md[self::CACHE_MODSEQ] < $modseq) {
$set = true;
$sync = $md[self::CACHE_MODSEQ];
} else {
$set = false;
$sync = 0;
}
$mbox_ob->setStatus(Horde_Imap_Client::STATUS_SYNCMODSEQ, $md[self::CACHE_MODSEQ]);
} else {
$set = true;
$sync = 0;
}
/* $modseq can be 0 - NOMODSEQ - so don't store in that case. */
if ($set && $modseq) {
$this->_cache->setMetaData($this->_selected, $uidvalid, array(
self::CACHE_MODSEQ => $modseq
));
}
return $sync;
}
/**
* Synchronizes the current mailbox cache with the server (using CONDSTORE
* or QRESYNC).
*/
protected function _condstoreSync()
{
$mbox_ob = $this->_mailboxOb();
/* Check that modseqs are available in mailbox. */
if (!($highestmodseq = $mbox_ob->getStatus(Horde_Imap_Client::STATUS_HIGHESTMODSEQ)) ||
!($modseq = $this->_updateModSeq($highestmodseq))) {
$mbox_ob->sync = true;
}
if ($mbox_ob->sync) {
return;
}
$uids_ob = $this->getIdsOb($this->_cache->get(
$this->_selected,
array(),
array(),
$mbox_ob->getStatus(Horde_Imap_Client::STATUS_UIDVALIDITY)
));
if (!count($uids_ob)) {
$mbox_ob->sync = true;
return;
}
/* Are we caching flags? */
if (array_key_exists(Horde_Imap_Client::FETCH_FLAGS, $this->_cacheFields())) {
$fquery = new Horde_Imap_Client_Fetch_Query();
$fquery->flags();
/* Update flags in cache. Cache will be updated in _fetch(). */
$this->_fetch(new Horde_Imap_Client_Fetch_Results(), array(
array(
'_query' => $fquery,
'changedsince' => $modseq,
'ids' => $uids_ob
)
));
}
/* Search for deleted messages, and remove from cache. */
$vanished = $this->vanished($this->_selected, $modseq, array(
'ids' => $uids_ob
));
$disappear = array_diff($uids_ob->ids, $vanished->ids);
if (!empty($disappear)) {
$this->_deleteMsgs($this->_selected, $this->getIdsOb($disappear));
}
$mbox_ob->sync = true;
}
/**
* Provide the list of available caching fields.
*
* @return array The list of available caching fields (fields are in the
* key).
*/
protected function _cacheFields()
{
$c = $this->getParam('cache');
$out = $c['fields'];
if (!$this->_capability()->isEnabled('CONDSTORE')) {
unset($out[Horde_Imap_Client::FETCH_FLAGS]);
}
return $out;
}
/**
* Return the current mailbox synchronization status.
*
* @param mixed $mailbox A mailbox. Either a Horde_Imap_Client_Mailbox
* object or a string (UTF-8).
*
* @return array An array with status data. (This data is not guaranteed
* to have any specific format).
*/
protected function _syncStatus($mailbox)
{
$status = $this->status(
$mailbox,
Horde_Imap_Client::STATUS_HIGHESTMODSEQ |
Horde_Imap_Client::STATUS_MESSAGES |
Horde_Imap_Client::STATUS_UIDNEXT_FORCE |
Horde_Imap_Client::STATUS_UIDVALIDITY
);
$fields = array('uidnext', 'uidvalidity');
if (empty($status['highestmodseq'])) {
$fields[] = 'messages';
} else {
$fields[] = 'highestmodseq';
}
$out = array();
$sync_map = array_flip(Horde_Imap_Client_Data_Sync::$map);
foreach ($fields as $val) {
$out[$sync_map[$val]] = $status[$val];
}
return array_filter($out);
}
/**
* Get a message UID by the Message-ID. Returns the last message in a
* mailbox that matches.
*
* @param Horde_Imap_Client_Mailbox $mailbox The mailbox to search
* @param string $msgid Message-ID.
*
* @return string UID (null if not found).
*/
protected function _getUidByMessageId($mailbox, $msgid)
{
if (!$msgid) {
return null;
}
$query = new Horde_Imap_Client_Search_Query();
$query->headerText('Message-ID', $msgid);
$res = $this->search($mailbox, $query, array(
'results' => array(Horde_Imap_Client::SEARCH_RESULTS_MAX)
));
return $res['max'];
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Cache.php 0000664 0001750 0001750 00000020011 13150761653 020733 0 ustar jan jan
* @category Horde
* @copyright 2005-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Cache
{
/**
* Base client object.
*
* @var Horde_Imap_Client_Base
*/
protected $_baseob;
/**
* Storage backend.
*
* @var Horde_Imap_Client_Cache_Backend
*/
protected $_backend;
/**
* Debug output.
*
* @var Horde_Imap_Client_Base_Debug
*/
protected $_debug = false;
/**
* The configuration params.
*
* @var array
*/
protected $_params = array();
/**
* Constructor.
*
* @param array $params Configuration parameters:
*
* - REQUIRED Parameters:
* - backend: (Horde_Imap_Client_Cache_Backend) The cache backend.
* - baseob: (Horde_Imap_Client_Base) The base client object.
*
* - Optional Parameters:
* - debug: (Horde_Imap_Client_Base_Debug) Debug object.
* DEFAULT: No debug output
*
*/
public function __construct(array $params = array())
{
$this->_backend = $params['backend'];
$this->_baseob = $params['baseob'];
$this->_backend->setParams(array(
'hostspec' => $this->_baseob->getParam('hostspec'),
'port' => $this->_baseob->getParam('port'),
'username' => $this->_baseob->getParam('username')
));
if (isset($params['debug']) &&
($params['debug'] instanceof Horde_Imap_Client_Base_Debug)) {
$this->_debug = $params['debug'];
$this->_debug->info(sprintf(
'CACHE: Using the %s storage driver.',
get_class($this->_backend)
));
}
}
/**
* Get information from the cache.
*
* @param string $mailbox An IMAP mailbox string.
* @param array $uids The list of message UIDs to retrieve
* information for. If empty, returns the list
* of cached UIDs.
* @param array $fields An array of fields to retrieve. If empty,
* returns all cached fields.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*
* @return array An array of arrays with the UID of the message as the
* key (if found) and the fields as values (will be
* undefined if not found). If $uids is empty, returns the
* full (unsorted) list of cached UIDs.
*/
public function get($mailbox, array $uids = array(), $fields = array(),
$uidvalid = null)
{
$mailbox = strval($mailbox);
if (empty($uids)) {
$ret = $this->_backend->getCachedUids($mailbox, $uidvalid);
} else {
$ret = $this->_backend->get($mailbox, $uids, $fields, $uidvalid);
if ($this->_debug && !empty($ret)) {
$this->_debug->info(sprintf(
'CACHE: Retrieved messages (%s [%s; %s])',
empty($fields) ? 'ALL' : implode(',', $fields),
$mailbox,
$this->_baseob->getIdsOb(array_keys($ret))->tostring_sort
));
}
}
return $ret;
}
/**
* Store information in cache.
*
* @param string $mailbox An IMAP mailbox string.
* @param array $data The list of data to save. The keys are the
* UIDs, the values are an array of information
* to save. If empty, do a check to make sure
* the uidvalidity is still valid.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
*/
public function set($mailbox, $data, $uidvalid)
{
$mailbox = strval($mailbox);
if (empty($data)) {
$this->_backend->getMetaData($mailbox, $uidvalid, array('uidvalid'));
} else {
$this->_backend->set($mailbox, $data, $uidvalid);
if ($this->_debug) {
$this->_debug->info(sprintf(
'CACHE: Stored messages [%s; %s]',
$mailbox,
$this->_baseob->getIdsOb(array_keys($data))->tostring_sort
));
}
}
}
/**
* Get metadata information for a mailbox.
*
* @param string $mailbox An IMAP mailbox string.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
* @param array $entries An array of entries to return. If empty,
* returns all metadata.
*
* @return array The requested metadata. Requested entries that do not
* exist will be undefined. The following entries are
* defaults and always present:
* - uidvalid: (integer) The UIDVALIDITY of the mailbox.
*/
public function getMetaData($mailbox, $uidvalid = null,
array $entries = array())
{
return $this->_backend->getMetaData(strval($mailbox), $uidvalid, $entries);
}
/**
* Set metadata information for a mailbox.
*
* @param string $mailbox An IMAP mailbox string.
* @param integer $uidvalid The IMAP uidvalidity value of the mailbox.
* @param array $data The list of data to save. The keys are the
* metadata IDs, the values are the associated
* data. The following labels are reserved:
* 'uidvalid'.
*/
public function setMetaData($mailbox, $uidvalid, array $data = array())
{
unset($data['uidvalid']);
if (!empty($data)) {
if (!empty($uidvalid)) {
$data['uidvalid'] = $uidvalid;
}
$mailbox = strval($mailbox);
$this->_backend->setMetaData($mailbox, $data);
if ($this->_debug) {
$this->_debug->info(sprintf(
'CACHE: Stored metadata (%s [%s])',
implode(',', array_keys($data)),
$mailbox
));
}
}
}
/**
* Delete messages in the cache.
*
* @param string $mailbox An IMAP mailbox string.
* @param array $uids The list of message UIDs to delete.
*/
public function deleteMsgs($mailbox, $uids)
{
if (empty($uids)) {
return;
}
$mailbox = strval($mailbox);
$this->_backend->deleteMsgs($mailbox, $uids);
if ($this->_debug) {
$this->_debug->info(sprintf(
'CACHE: Deleted messages [%s; %s]',
$mailbox,
$this->_baseob->getIdsOb($uids)->tostring_sort
));
}
}
/**
* Delete a mailbox from the cache.
*
* @param string $mbox The mailbox to delete.
*/
public function deleteMailbox($mbox)
{
$mbox = strval($mbox);
$this->_backend->deleteMailbox($mbox);
if ($this->_debug) {
$this->_debug->info(sprintf(
'CACHE: Deleted mailbox [%s]',
$mbox
));
}
}
/**
* Clear the cache.
*
* @since 2.9.0
*
* @param integer $lifetime Only delete entries older than this (in
* seconds). If null, deletes all entries.
*/
public function clear($lifetime = null)
{
$this->_backend->clear($lifetime);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/DateTime.php 0000664 0001750 0001750 00000007025 13150761653 021436 0 ustar jan jan
* @category Horde
* @copyright 2012-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_DateTime extends DateTime
{
/**
*/
public function __construct($time = null, $tz = null)
{
/* See https://bugs.php.net/bug.php?id=67118 */
$bug_67118 = (version_compare(PHP_VERSION, '5.6', '>=')) ||
in_array(PHP_VERSION, array('5.4.29', '5.5.13'));
$tz = new DateTimeZone('UTC');
/* Bug #14381 Catch malformed offset - which doesn't cause
DateTime to throw exception. */
if (substr(rtrim($time), -5) === ' 0000') {
$time = substr(trim($time), 0, strlen(trim($time)) - 5) . ' +0000';
try {
if ($bug_67118) {
new DateTime($time, $tz);
}
parent::__construct($time, $tz);
return;
} catch (Exception $e) {}
}
try {
if ($bug_67118) {
new DateTime($time, $tz);
}
parent::__construct($time, $tz);
return;
} catch (Exception $e) {}
/* Check for malformed day-of-week parts, usually incorrectly
* localized. E.g. Fr, 15 Apr 2016 15:15:09 +0000 */
if (!preg_match("/^(Mon|Tue|Wed|Thu|Fri|Sat|Sun),/", $time)) {
$time = preg_replace("/^(\S*,)/", '', $time, 1, $i);
if ($i) {
try {
if ($bug_67118) {
new DateTime($time, $tz);
}
parent::__construct($time, $tz);
return;
} catch (Exception $e) {}
}
}
/* Bug #5717 - Check for UT vs. UTC. */
if (substr(rtrim($time), -3) === ' UT') {
try {
if ($bug_67118) {
new DateTime($time . 'C', $tz);
}
parent::__construct($time . 'C', $tz);
return;
} catch (Exception $e) {}
}
/* Bug #9847 - Catch paranthesized timezone information at end of date
* string. */
$date = preg_replace("/\s*\([^\)]+\)\s*$/", '', $time, -1, $i);
if ($i) {
try {
if ($bug_67118) {
new DateTime($date, $tz);
}
parent::__construct($date, $tz);
return;
} catch (Exception $e) {}
}
parent::__construct('@-1', $tz);
}
/**
* String representation: UNIX timestamp.
*/
public function __toString()
{
return $this->error()
? '0'
: strval($this->getTimestamp());
}
/**
* Was this an unparseable date?
*
* @return boolean True if unparseable.
*/
public function error()
{
return ($this->getTimestamp() === -1);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Exception.php 0000664 0001750 0001750 00000015276 13150761653 021707 0 ustar jan jan
* @category Horde
* @copyright 2008-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*/
class Horde_Imap_Client_Exception extends Horde_Exception_Wrapped
{
/* Error message codes. */
/**
* Unspecified error (DEFAULT).
*/
const UNSPECIFIED = 0;
/**
* There was an unrecoverable error in UTF7IMAP -> UTF8 conversion.
*/
const UTF7IMAP_CONVERSION = 3;
/**
* The server ended the connection.
*/
const DISCONNECT = 4;
/**
* The charset used in the search query is not supported on the
* server. */
const BADCHARSET = 5;
/**
* There were errors parsing the MIME/RFC 2822 header of the part.
*/
const PARSEERROR = 6;
/**
* The server could not decode the MIME part (see RFC 3516).
*/
const UNKNOWNCTE = 7;
/**
* The comparator specified by setComparator() was not recognized by the
* IMAP server
*/
const BADCOMPARATOR = 9;
/**
* RFC 7162 [3.1.2.2] - All mailboxes are not required to support
* mod-sequences.
*/
const MBOXNOMODSEQ = 10;
/**
* Thrown if server denies the network connection.
*/
const SERVER_CONNECT = 11;
/**
* Thrown if read error for server response.
*/
const SERVER_READERROR = 12;
/**
* Thrown if write error in server interaction.
*/
const SERVER_WRITEERROR = 16;
/**
* Thrown on CATENATE if the URL is invalid.
*/
const CATENATE_BADURL = 13;
/**
* Thrown on CATENATE if the message was too big.
*/
const CATENATE_TOOBIG = 14;
/**
* Thrown on CREATE if special-use attribute is not supported.
*/
const USEATTR = 15;
/**
* The user did not have permissions to carry out the operation.
*/
const NOPERM = 17;
/**
* The operation was not successful because another user is holding
* a necessary resource. The operation may succeed if attempted later.
*/
const INUSE = 18;
/**
* The operation failed because data on the server was corrupt.
*/
const CORRUPTION = 19;
/**
* The operation failed because it exceeded some limit on the server.
*/
const LIMIT = 20;
/**
* The operation failed because the user is over their quota.
*/
const OVERQUOTA = 21;
/**
* The operation failed because the requested creation object already
* exists.
*/
const ALREADYEXISTS = 22;
/**
* The operation failed because the requested deletion object did not
* exist.
*/
const NONEXISTENT = 23;
/**
* Setting metadata failed because the size of its value is too large.
* The maximum octet count the server is willing to accept will be
* in the exception message string.
*/
const METADATA_MAXSIZE = 24;
/**
* Setting metadata failed because the maximum number of allowed
* annotations has already been reached.
*/
const METADATA_TOOMANY = 25;
/**
* Setting metadata failed because the server does not support private
* annotations on one of the specified mailboxes.
*/
const METADATA_NOPRIVATE = 26;
/**
* Invalid metadata entry.
*/
const METADATA_INVALID = 27;
// Login failures
/**
* Could not start mandatory TLS connection.
*/
const LOGIN_TLSFAILURE = 100;
/**
* Could not find an available authentication method.
*/
const LOGIN_NOAUTHMETHOD = 101;
/**
* Generic authentication failure.
*/
const LOGIN_AUTHENTICATIONFAILED = 102;
/**
* Remote server is unavailable.
*/
const LOGIN_UNAVAILABLE = 103;
/**
* Authentication succeeded, but authorization failed.
*/
const LOGIN_AUTHORIZATIONFAILED = 104;
/**
* Authentication is no longer permitted with this passphrase.
*/
const LOGIN_EXPIRED = 105;
/**
* Login requires privacy.
*/
const LOGIN_PRIVACYREQUIRED = 106;
/**
* Server verification failed (SCRAM authentication).
*/
const LOGIN_SERVER_VERIFICATION_FAILED = 107;
// Mailbox access failures
/**
* Could not open/access mailbox
*/
const MAILBOX_NOOPEN = 200;
/**
* Could not complete the command because the mailbox is read-only
*/
const MAILBOX_READONLY = 201;
// POP3 specific error codes
/**
* Temporary issue. Generally, there is no need to alarm the user for
* errors of this type.
*/
const POP3_TEMP_ERROR = 300;
/**
* Permanent error indicated by server.
*/
const POP3_PERM_ERROR = 301;
// Unsupported feature error codes
/**
* Function/feature is not supported on this server.
*/
const NOT_SUPPORTED = 400;
/**
* Raw error message (in English).
*
* @since 2.18.0
*
* @var string
*/
public $raw_msg = '';
/**
* Constructor.
*
* @param string $message Error message (non-translated).
* @param code $code Error code.
*/
public function __construct($message = null, $code = null)
{
parent::__construct($message, $code);
$this->raw_msg = $this->message;
try {
$this->message = Horde_Imap_Client_Translation::t($this->message);
} catch (Horde_Translation_Exception $e) {}
}
/**
* Allow the error message to be altered.
*
* @param string $msg Error message.
*/
public function setMessage($msg)
{
$this->message = strval($msg);
}
/**
* Allow the error code to be altered.
*
* @param integer $code Error code.
*/
public function setCode($code)
{
$this->code = intval($code);
}
/**
* Perform substitution of variables in the error message.
*
* Needed to allow for correct translation of error message.
*
* @since 2.22.0
*
* @param array $args Arguments used for substitution.
*/
public function messagePrintf(array $args = array())
{
$this->raw_msg = vsprintf($this->raw_msg, $args);
$this->message = vsprintf($this->message, $args);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Ids.php 0000664 0001750 0001750 00000027372 13150761653 020470 0 ustar jan jan
* @category Horde
* @copyright 2011-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*
* @property-read boolean $all Does this represent an ALL message set?
* @property-read array $ids The list of IDs.
* @property-read boolean $largest Does this represent the largest ID in use?
* @property-read string $max The largest ID (@since 2.20.0).
* @property-read string $min The smallest ID (@since 2.20.0).
* @property-read string $range_string Generates a range string consisting of
* all messages between begin and end of
* ID list.
* @property-read boolean $search_res Does this represent a search result?
* @property-read boolean $sequence Are these sequence IDs? If false, these
* are UIDs.
* @property-read boolean $special True if this is a "special" ID
* representation.
* @property-read string $tostring Return the non-sorted string
* representation.
* @property-read string $tostring_sort Return the sorted string
* representation.
*/
class Horde_Imap_Client_Ids implements Countable, Iterator, Serializable
{
/**
* "Special" representation constants.
*/
const ALL = "\01";
const SEARCH_RES = "\02";
const LARGEST = "\03";
/**
* Allow duplicate IDs?
*
* @var boolean
*/
public $duplicates = false;
/**
* List of IDs.
*
* @var mixed
*/
protected $_ids = array();
/**
* Are IDs message sequence numbers?
*
* @var boolean
*/
protected $_sequence = false;
/**
* Are IDs sorted?
*
* @var boolean
*/
protected $_sorted = false;
/**
* Constructor.
*
* @param mixed $ids See self::add().
* @param boolean $sequence Are $ids message sequence numbers?
*/
public function __construct($ids = null, $sequence = false)
{
$this->add($ids);
$this->_sequence = $sequence;
}
/**
*/
public function __get($name)
{
switch ($name) {
case 'all':
return ($this->_ids === self::ALL);
case 'ids':
return is_array($this->_ids)
? $this->_ids
: array();
case 'largest':
return ($this->_ids === self::LARGEST);
case 'max':
$this->sort();
return end($this->_ids);
case 'min':
$this->sort();
return reset($this->_ids);
case 'range_string':
if (!count($this)) {
return '';
}
$min = $this->min;
$max = $this->max;
return ($min == $max)
? $min
: $min . ':' . $max;
case 'search_res':
return ($this->_ids === self::SEARCH_RES);
case 'sequence':
return (bool)$this->_sequence;
case 'special':
return is_string($this->_ids);
case 'tostring':
case 'tostring_sort':
if ($this->all) {
return '1:*';
} elseif ($this->largest) {
return '*';
} elseif ($this->search_res) {
return '$';
}
return strval($this->_toSequenceString($name == 'tostring_sort'));
}
}
/**
*/
public function __toString()
{
return $this->tostring;
}
/**
* Add IDs to the current object.
*
* @param mixed $ids Either self::ALL, self::SEARCH_RES, self::LARGEST,
* Horde_Imap_Client_Ids object, array, or sequence
* string.
*/
public function add($ids)
{
if (!is_null($ids)) {
if (is_string($ids) &&
in_array($ids, array(self::ALL, self::SEARCH_RES, self::LARGEST))) {
$this->_ids = $ids;
} elseif ($add = $this->_resolveIds($ids)) {
if (is_array($this->_ids) && !empty($this->_ids)) {
foreach ($add as $val) {
$this->_ids[] = $val;
}
} else {
$this->_ids = $add;
}
if (!$this->duplicates) {
$this->_ids = (count($this->_ids) > 25000)
? array_unique($this->_ids)
: array_keys(array_flip($this->_ids));
}
}
$this->_sorted = is_array($this->_ids) && (count($this->_ids) === 1);
}
}
/**
* Removed IDs from the current object.
*
* @since 2.17.0
*
* @param mixed $ids Either Horde_Imap_Client_Ids object, array, or
* sequence string.
*/
public function remove($ids)
{
if (!$this->isEmpty() &&
($remove = $this->_resolveIds($ids))) {
$this->_ids = array_diff($this->_ids, array_unique($remove));
}
}
/**
* Is this object empty (i.e. does not contain IDs)?
*
* @return boolean True if object is empty.
*/
public function isEmpty()
{
return (is_array($this->_ids) && !count($this->_ids));
}
/**
* Reverses the order of the IDs.
*/
public function reverse()
{
if (is_array($this->_ids)) {
$this->_ids = array_reverse($this->_ids);
}
}
/**
* Sorts the IDs.
*/
public function sort()
{
if (!$this->_sorted && is_array($this->_ids)) {
$this->_sort($this->_ids);
$this->_sorted = true;
}
}
/**
* Sorts the IDs numerically.
*
* @param array $ids The array list.
*/
protected function _sort(&$ids)
{
sort($ids, SORT_NUMERIC);
}
/**
* Split the sequence string at an approximate length.
*
* @since 2.7.0
*
* @param integer $length Length to split.
*
* @return array A list containing individual sequence strings.
*/
public function split($length)
{
$id = new Horde_Stream_Temp();
$id->add($this->tostring_sort, true);
$out = array();
do {
$out[] = $id->substring(0, $length) . $id->getToChar(',');
} while (!$id->eof());
return $out;
}
/**
* Resolve the $ids input to add() and remove().
*
* @param mixed $ids Either Horde_Imap_Client_Ids object, array, or
* sequence string.
*
* @return array An array of IDs.
*/
protected function _resolveIds($ids)
{
if ($ids instanceof Horde_Imap_Client_Ids) {
return $ids->ids;
} elseif (is_array($ids)) {
return $ids;
} elseif (is_string($ids) || is_integer($ids)) {
return is_numeric($ids)
? array($ids)
: $this->_fromSequenceString($ids);
}
return array();
}
/**
* Create an IMAP message sequence string from a list of indices.
*
* Index Format: range_start:range_end,uid,uid2,...
*
* @param boolean $sort Numerically sort the IDs before creating the
* range?
*
* @return string The IMAP message sequence string.
*/
protected function _toSequenceString($sort = true)
{
if (empty($this->_ids)) {
return '';
}
$in = $this->_ids;
if ($sort && !$this->_sorted) {
$this->_sort($in);
}
$first = $last = array_shift($in);
$i = count($in) - 1;
$out = array();
foreach ($in as $key => $val) {
if (($last + 1) == $val) {
$last = $val;
}
if (($i == $key) || ($last != $val)) {
if ($last == $first) {
$out[] = $first;
if ($i == $key) {
$out[] = $val;
}
} else {
$out[] = $first . ':' . $last;
if (($i == $key) && ($last != $val)) {
$out[] = $val;
}
}
$first = $last = $val;
}
}
return empty($out)
? $first
: implode(',', $out);
}
/**
* Parse an IMAP message sequence string into a list of indices.
*
* @see _toSequenceString()
*
* @param string $str The IMAP message sequence string.
*
* @return array An array of indices.
*/
protected function _fromSequenceString($str)
{
$ids = array();
$str = trim($str);
if (!strlen($str)) {
return $ids;
}
$idarray = explode(',', $str);
foreach ($idarray as $val) {
$range = explode(':', $val);
if (isset($range[1])) {
for ($i = min($range), $j = max($range); $i <= $j; ++$i) {
$ids[] = $i;
}
} else {
$ids[] = $val;
}
}
return $ids;
}
/* Countable methods. */
/**
*/
public function count()
{
return is_array($this->_ids)
? count($this->_ids)
: 0;
}
/* Iterator methods. */
/**
*/
public function current()
{
return is_array($this->_ids)
? current($this->_ids)
: null;
}
/**
*/
public function key()
{
return is_array($this->_ids)
? key($this->_ids)
: null;
}
/**
*/
public function next()
{
if (is_array($this->_ids)) {
next($this->_ids);
}
}
/**
*/
public function rewind()
{
if (is_array($this->_ids)) {
reset($this->_ids);
}
}
/**
*/
public function valid()
{
return !is_null($this->key());
}
/* Serializable methods. */
/**
*/
public function serialize()
{
$save = array();
if ($this->duplicates) {
$save['d'] = 1;
}
if ($this->_sequence) {
$save['s'] = 1;
}
if ($this->_sorted) {
$save['is'] = 1;
}
switch ($this->_ids) {
case self::ALL:
$save['a'] = true;
break;
case self::LARGEST:
$save['l'] = true;
break;
case self::SEARCH_RES:
$save['sr'] = true;
break;
default:
$save['i'] = strval($this);
break;
}
return serialize($save);
}
/**
*/
public function unserialize($data)
{
$save = @unserialize($data);
$this->duplicates = !empty($save['d']);
$this->_sequence = !empty($save['s']);
$this->_sorted = !empty($save['is']);
if (isset($save['a'])) {
$this->_ids = self::ALL;
} elseif (isset($save['l'])) {
$this->_ids = self::LARGEST;
} elseif (isset($save['sr'])) {
$this->_ids = self::SEARCH_RES;
} elseif (isset($save['i'])) {
$this->add($save['i']);
}
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Mailbox.php 0000664 0001750 0001750 00000007441 13150761653 021337 0 ustar jan jan
* @category Horde
* @copyright 2011-2017 Horde LLC
* @license http://www.horde.org/licenses/lgpl21 LGPL 2.1
* @package Imap_Client
*
* @property-read string $list_escape Escapes mailbox for use in LIST
* command (UTF-8).
* @property-read string $utf7imap Mailbox in UTF7-IMAP.
* @property-read string $utf8 Mailbox in UTF-8.
*/
class Horde_Imap_Client_Mailbox implements Serializable
{
/**
* UTF7-IMAP representation of mailbox.
* If boolean true, it is identical to UTF-8 representation.
*
* @var mixed
*/
protected $_utf7imap;
/**
* UTF8 representation of mailbox.
*
* @var string
*/
protected $_utf8;
/**
* Shortcut to obtaining mailbox object.
*
* @param string $mbox The mailbox name.
* @param boolean $utf7imap Is mailbox UTF7-IMAP encoded? Otherwise,
* mailbox is assumed to be UTF-8.
*
* @return Horde_Imap_Client_Mailbox A mailbox object.
*/
public static function get($mbox, $utf7imap = false)
{
return ($mbox instanceof Horde_Imap_Client_Mailbox)
? $mbox
: new Horde_Imap_Client_Mailbox($mbox, $utf7imap);
}
/**
* Constructor.
*
* @param string $mbox The mailbox name.
* @param boolean $utf7imap Is mailbox UTF7-IMAP encoded (true).
* Otherwise, mailbox is assumed to be UTF-8
* encoded.
*/
public function __construct($mbox, $utf7imap = false)
{
if (strcasecmp($mbox, 'INBOX') === 0) {
$mbox = 'INBOX';
}
if ($utf7imap) {
$this->_utf7imap = $mbox;
} else {
$this->_utf8 = $mbox;
}
}
/**
*/
public function __get($name)
{
switch ($name) {
case 'list_escape':
return preg_replace("/\*+/", '%', $this->utf8);
case 'utf7imap':
if (!isset($this->_utf7imap)) {
$n = Horde_Imap_Client_Utf7imap::Utf8ToUtf7Imap($this->_utf8);
$this->_utf7imap = ($n == $this->_utf8)
? true
: $n;
}
return ($this->_utf7imap === true)
? $this->_utf8
: $this->_utf7imap;
case 'utf8':
if (!isset($this->_utf8)) {
$this->_utf8 = Horde_Imap_Client_Utf7imap::Utf7ImapToUtf8($this->_utf7imap);
if ($this->_utf8 == $this->_utf7imap) {
$this->_utf7imap = true;
}
}
return (string)$this->_utf8;
}
}
/**
*/
public function __toString()
{
return $this->utf8;
}
/**
* Compares this mailbox to another mailbox string.
*
* @return boolean True if the items are equal.
*/
public function equals($mbox)
{
return ($this->utf8 == $mbox);
}
/* Serializable methods. */
/**
*/
public function serialize()
{
return json_encode(array($this->_utf7imap, $this->_utf8));
}
/**
*/
public function unserialize($data)
{
list($this->_utf7imap, $this->_utf8) = json_decode($data, true);
}
}
Horde_Imap_Client-2.29.15/lib/Horde/Imap/Client/Socket.php 0000664 0001750 0001750 00000547325 13150761653 021206 0 ustar jan jan
* - RFC 2086/4314: ACL
* - RFC 2087: QUOTA
* - RFC 2088: LITERAL+
* - RFC 2195: AUTH=CRAM-MD5
* - RFC 2221: LOGIN-REFERRALS
* - RFC 2342: NAMESPACE
* - RFC 2595/4616: TLS & AUTH=PLAIN
* - RFC 2831: DIGEST-MD5 authentication mechanism (obsoleted by RFC 6331)
* - RFC 2971: ID
* - RFC 3348: CHILDREN
* - RFC 3501: IMAP4rev1 specification
* - RFC 3502: MULTIAPPEND
* - RFC 3516: BINARY
* - RFC 3691: UNSELECT
* - RFC 4315: UIDPLUS
* - RFC 4422: SASL Authentication (for DIGEST-MD5)
* - RFC 4466: Collected extensions (updates RFCs 2088, 3501, 3502, 3516)
* - RFC 4469/5550: CATENATE
* - RFC 4731: ESEARCH
* - RFC 4959: SASL-IR
* - RFC 5032: WITHIN
* - RFC 5161: ENABLE
* - RFC 5182: SEARCHRES
* - RFC 5255: LANGUAGE/I18NLEVEL
* - RFC 5256: THREAD/SORT
* - RFC 5258: LIST-EXTENDED
* - RFC 5267: ESORT; PARTIAL search return option
* - RFC 5464: METADATA
* - RFC 5530: IMAP Response Codes
* - RFC 5802: AUTH=SCRAM-SHA-1
* - RFC 5819: LIST-STATUS
* - RFC 5957: SORT=DISPLAY
* - RFC 6154: SPECIAL-USE/CREATE-SPECIAL-USE
* - RFC 6203: SEARCH=FUZZY
* - RFC 6851: MOVE
* - RFC 6855: UTF8=ACCEPT/UTF8=ONLY
* - RFC 6858: DOWNGRADED response code
* - RFC 7162: CONDSTORE/QRESYNC
*
*
* Implements the following non-RFC extensions:
* * - draft-ietf-morg-inthread-01: THREAD=REFS * - draft-daboo-imap-annotatemore-07: ANNOTATEMORE * - draft-daboo-imap-annotatemore-08: ANNOTATEMORE2 * - XIMAPPROXY * Requires imapproxy v1.2.7-rc1 or later * See https://squirrelmail.svn.sourceforge.net/svnroot/squirrelmail/trunk/imap_proxy/README * - AUTH=XOAUTH2 * https://developers.google.com/gmail/xoauth2_protocol ** * TODO (or not necessary?): *
* - RFC 2177: IDLE * - RFC 2193: MAILBOX-REFERRALS * - RFC 4467/5092/5524/5550/5593: URLAUTH, URLAUTH=BINARY, URL-PARTIAL * - RFC 4978: COMPRESS=DEFLATE * See: http://bugs.php.net/bug.php?id=48725 * - RFC 5257: ANNOTATE (Experimental) * - RFC 5259: CONVERT * - RFC 5267: CONTEXT=SEARCH; CONTEXT=SORT * - RFC 5465: NOTIFY * - RFC 5466: FILTERS * - RFC 6785: IMAPSIEVE * - RFC 7377: MULTISEARCH ** * @author Michael Slusarz
multipart/alternative test.