mirror of
https://github.com/cytopia/devilbox.git
synced 2024-12-30 17:46:56 +00:00
912 lines
24 KiB
PHP
912 lines
24 KiB
PHP
<?php
|
|
/**
|
|
* @author cytopia
|
|
* @date 2016-11-06
|
|
*
|
|
* Fixed constructor name to __construct in order to be
|
|
* compatible with PHP >5.5
|
|
*/
|
|
|
|
|
|
/**
|
|
* Class to read mbox mail files.
|
|
*
|
|
* PHP versions 4 and 5
|
|
*
|
|
* @category Mail
|
|
* @package Mail_Mbox
|
|
* @author Roberto Berto <darkelder@php.net>
|
|
* @author Christian Weiske <cweiske@php.net>
|
|
* @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
|
|
* @version CVS: $Id: Mbox.php 290486 2009-11-10 20:42:51Z cweiske $
|
|
* @link http://pear.php.net/package/Mail_Mbox
|
|
*/
|
|
require_once 'PEAR.php';
|
|
|
|
/**
|
|
* The file has been modified since it has been opened.
|
|
* You should close and re-open it.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_MODIFIED', 2101);
|
|
|
|
/**
|
|
* The mail mbox file doesn't exist.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_FILE_NOT_EXISTING', 2102);
|
|
|
|
/**
|
|
* There is no message with the given number.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_MESSAGE_NOT_EXISTING', 2103);
|
|
|
|
/**
|
|
* No permission to access the file.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_NO_PERMISSION', 2104);
|
|
|
|
/**
|
|
* The file cannot be opened.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_CANNOT_OPEN', 2105);
|
|
|
|
/**
|
|
* The file cannot be closed due to some strange things.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_CANNOT_CLOSE', 2106);
|
|
|
|
/**
|
|
* The file cannot be read.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_CANNOT_READ', 2107);
|
|
|
|
/**
|
|
* Failed to create a temporary file.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_CANNOT_CREATE_TMP', 2108);
|
|
|
|
/**
|
|
* The file cannot be written.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_CANNOT_WRITE', 2109);
|
|
|
|
/**
|
|
* The file is not open.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_NOT_OPEN', 2110);
|
|
|
|
/**
|
|
* The resource isn't valid anymore.
|
|
*/
|
|
define('MAIL_MBOX_ERROR_NO_RESOURCE', 2111);
|
|
|
|
/**
|
|
* Message is invalid and would trash the file
|
|
*/
|
|
define('MAIL_MBOX_ERROR_MSG_INVALID', 2112);
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Class to read mbox mail files.
|
|
*
|
|
* An mbox mail file is contains plain emails concatenated in one
|
|
* big file. Since each mail starts with "From ", and ends with a newline,
|
|
* they can be separated from each other.
|
|
*
|
|
* This class takes a mbox filename in the constructor, generates an
|
|
* index where the mails start and end when calling open() and returns
|
|
* single mails with get(), using the positions in the index.
|
|
*
|
|
* With the help of this class, you also can add(), remove() and update()
|
|
* messages in the mbox file. When calling one of this methods, the class
|
|
* checks if the file has been modified since the index was created -
|
|
* changing the file with the wrong positions in the index would very likely
|
|
* corrupt it.
|
|
* This check is not done when retrieving single messages via get(), as this
|
|
* would slow down the process if you retrieve thousands of mails. You can,
|
|
* however, call hasBeenModified() before using get() to check for modification
|
|
* yourself. If the method returns true, you should close() and re-open() the
|
|
* file.
|
|
*
|
|
* If something strange happens and you don't know why, activate debugging with
|
|
* setDebug(true). You also can modify the temporary directory in which changed
|
|
* mboxes are stored when adding/removing/modifying by using setTmpDir('/path/');
|
|
*
|
|
* See @link tags for specifications.
|
|
*
|
|
* @category Mail
|
|
* @package Mail_Mbox
|
|
* @author Roberto Berto <darkelder@php.net>
|
|
* @author Christian Weiske <cweiske@php.net>
|
|
* @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
|
|
* @link http://pear.php.net/package/Mail_Mbox
|
|
* @link http://en.wikipedia.org/wiki/Mbox
|
|
* @link http://www.qmail.org/man/man5/mbox.html
|
|
*/
|
|
class Mail_Mbox extends PEAR
|
|
{
|
|
/**
|
|
* File resource / handle
|
|
*
|
|
* @var resource
|
|
* @access protected
|
|
*/
|
|
var $_resource = null;
|
|
|
|
/**
|
|
* Message index. Each mail has its own subarray,
|
|
* which contains the start position and end position
|
|
* as first and second subindex.
|
|
*
|
|
* @var array
|
|
* @access protected
|
|
*/
|
|
var $_index = null;
|
|
|
|
/**
|
|
* Timestamp at which the file has been modified last.
|
|
*
|
|
* @var int
|
|
* @access protected
|
|
*/
|
|
var $_lastModified = null;
|
|
|
|
/**
|
|
* Debug mode
|
|
*
|
|
* Set to true to turn on debug mode.
|
|
*
|
|
* @var bool
|
|
* @access public
|
|
* @see setDebug()
|
|
* @see getDebug()
|
|
*/
|
|
var $debug = false;
|
|
|
|
/**
|
|
* Directory in which the temporary mbox files are created.
|
|
* Even if it's a unix directory, it does work on windows as
|
|
* the only function it's used in is tempnam which automatically
|
|
* chooses the right temp directory if this here doesn't exist.
|
|
* So this variable is for special needs only.
|
|
*
|
|
* @var string
|
|
* @access public
|
|
* @see getTmpDir()
|
|
* @see setTmpDir()
|
|
*/
|
|
var $tmpdir = '/tmp';
|
|
|
|
/**
|
|
* Determines if the file is automatically re-opened and its
|
|
* structure is parsed after modifying it. Setting this to false
|
|
* makes you responsible for calling open() by hand, but is
|
|
* *a lot* faster when appending many messages.
|
|
*
|
|
* @var bool
|
|
* @access public
|
|
*/
|
|
var $autoReopen = true;
|
|
|
|
|
|
|
|
/**
|
|
* Create a new Mbox class instance.
|
|
* After creating it, you should use open().
|
|
*
|
|
* @param string $file Filename to open.
|
|
*
|
|
* @access public
|
|
*/
|
|
function __construct($file)
|
|
{
|
|
$this->_file = $file;
|
|
}
|
|
|
|
/**
|
|
* Open the mbox file
|
|
*
|
|
* Also, this function will process the Mbox and create a cache
|
|
* that tells each message start and end bytes.
|
|
*
|
|
* @return boolean|PEAR_Error True if all went ok, PEAR_Error on failure
|
|
* @access public
|
|
*/
|
|
function open($create = false)
|
|
{
|
|
// check if file exists else return pear error
|
|
if (!is_file($this->_file)) {
|
|
if ($create) {
|
|
$ret = $this->_create();
|
|
if (PEAR::isError($ret)) {
|
|
return $ret;
|
|
}
|
|
} else {
|
|
return PEAR::raiseError(
|
|
'Cannot open the mbox file "'
|
|
. $this->_file . '": file does not exist.',
|
|
MAIL_MBOX_ERROR_FILE_NOT_EXISTING
|
|
);
|
|
}
|
|
}
|
|
|
|
// opening the file
|
|
$this->_lastModified = filemtime($this->_file);
|
|
$this->_resource = fopen($this->_file, 'r');
|
|
if (!is_resource($this->_resource)) {
|
|
return PEAR::raiseError(
|
|
'Cannot open the mbox file: maybe without permission.',
|
|
MAIL_MBOX_ERROR_NO_PERMISSION
|
|
);
|
|
}
|
|
|
|
// process the file and get the messages bytes offsets
|
|
$this->_process();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Creates the file
|
|
*
|
|
* @return boolean True if it was created, false if it already
|
|
* existed. PEAR_Error in case it could not
|
|
* be created.
|
|
*
|
|
* @access protected
|
|
*/
|
|
function _create()
|
|
{
|
|
if (is_file($this->_file)) {
|
|
return false;
|
|
}
|
|
|
|
//We should maybe try to check if the directory
|
|
// is writable here. But that's too much fuss for now.
|
|
touch($this->_file);
|
|
|
|
if (is_file($this->_file)) {
|
|
return true;
|
|
}
|
|
|
|
//error
|
|
return PEAR::raiseError(
|
|
'File could not be created',
|
|
MAIL_MBOX_ERROR_CANNOT_WRITE
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Re-opens the file and parses the messages again.
|
|
* Used by other methods to be able to be able to prevent
|
|
* re-opening the file.
|
|
*
|
|
* @return mixed See open() for return values. Returns true if
|
|
* $this->autoReopen is false.
|
|
* @access protected
|
|
*/
|
|
function _reopen()
|
|
{
|
|
if ($this->autoReopen) {
|
|
return $this->open();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Close a Mbox
|
|
*
|
|
* Close the Mbox file opened by open()
|
|
*
|
|
* @return mixed true on success, else PEAR_Error
|
|
* @access public
|
|
*/
|
|
function close()
|
|
{
|
|
if (!is_resource($this->_resource)) {
|
|
return PEAR::raiseError(
|
|
'Cannot close the mbox file because it was not open.',
|
|
MAIL_MBOX_ERROR_NOT_OPEN
|
|
);
|
|
}
|
|
|
|
if (!fclose($this->_resource)) {
|
|
return PEAR::raiseError(
|
|
'Cannot close the mbox, maybe file is being used (?)',
|
|
MAIL_MBOX_ERROR_CANNOT_CLOSE
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get number of messages in this mbox
|
|
*
|
|
* @return int Number of messages on Mbox (starting on 1,
|
|
* 0 if no message exists)
|
|
* @access public
|
|
*/
|
|
function size()
|
|
{
|
|
if ($this->_index !== null) {
|
|
return sizeof($this->_index);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a message from the mbox
|
|
*
|
|
* Note: Message numbers start from 0.
|
|
*
|
|
* @param int $message The number of the message to retrieve
|
|
*
|
|
* @return string Return the message, PEAR_Error on error
|
|
* @access public
|
|
*/
|
|
function get($message)
|
|
{
|
|
// checking if we have bytes locations for this message
|
|
if (!is_array($this->_index[$message])) {
|
|
return PEAR::raiseError(
|
|
'Message does not exist.',
|
|
MAIL_MBOX_ERROR_MESSAGE_NOT_EXISTING
|
|
);
|
|
}
|
|
|
|
// getting bytes locations
|
|
$bytesStart = $this->_index[$message][0];
|
|
$bytesEnd = $this->_index[$message][1];
|
|
|
|
// a debug feature to show the bytes locations
|
|
if ($this->debug) {
|
|
printf("%08d=%08d<br />", $bytesStart, $bytesEnd);
|
|
}
|
|
|
|
if (!is_resource($this->_resource)) {
|
|
return PEAR::raiseError(
|
|
'Mbox resource is not valid. Maybe you need to re-open it?',
|
|
MAIL_MBOX_ERROR_NO_RESOURCE
|
|
);
|
|
}
|
|
|
|
// seek to start of message
|
|
if (fseek($this->_resource, $bytesStart) == -1) {
|
|
return PEAR::raiseError(
|
|
'Cannot read message bytes',
|
|
MAIL_MBOX_ERROR_CANNOT_READ
|
|
);
|
|
}
|
|
|
|
if ($bytesEnd - $bytesStart <= 0) {
|
|
return PEAR::raiseError(
|
|
'Message byte length is negative',
|
|
MAIL_MBOX_ERROR_CANNOT_READ
|
|
);
|
|
}
|
|
|
|
// reading and returning message
|
|
// (bytes to read = difference of bytes locations)
|
|
$msg = fread($this->_resource, $bytesEnd - $bytesStart);
|
|
return $this->_unescapeMessage($msg);
|
|
}
|
|
|
|
/**
|
|
* Remove a message from Mbox and save it.
|
|
*
|
|
* Note: messages start with 0.
|
|
*
|
|
* @param int $message The number of the message to remove, or
|
|
* array of message ids to remove
|
|
*
|
|
* @return mixed Return true else PEAR_Error
|
|
* @access public
|
|
*/
|
|
function remove($message)
|
|
{
|
|
if ($this->hasBeenModified()) {
|
|
return PEAR::raiseError(
|
|
'File has been modified since loading. Re-open the file.',
|
|
MAIL_MBOX_ERROR_MODIFIED
|
|
);
|
|
}
|
|
|
|
// convert single message to array
|
|
if (!is_array($message)) {
|
|
$message = array($message);
|
|
}
|
|
|
|
// checking if we have bytes locations for this message
|
|
foreach ($message as $msg) {
|
|
if (!isset($this->_index[$msg])
|
|
|| !is_array($this->_index[$msg])
|
|
) {
|
|
return PEAR::raiseError(
|
|
'Message ' . $msg . 'does not exist.',
|
|
MAIL_MBOX_ERROR_MESSAGE_NOT_EXISTING
|
|
);
|
|
}
|
|
}
|
|
|
|
// changing umask for security reasons
|
|
$umaskOld = umask(077);
|
|
// creating temp file
|
|
$ftempname = tempnam($this->tmpdir, 'Mail_Mbox');
|
|
// returning to old umask
|
|
umask($umaskOld);
|
|
|
|
$ftemp = fopen($ftempname, 'w');
|
|
if ($ftemp === false) {
|
|
return PEAR::raiseError(
|
|
'Cannot create a temp file "' . $ftempname . '".',
|
|
MAIL_MBOX_ERROR_CANNOT_CREATE_TMP
|
|
);
|
|
}
|
|
|
|
// writing only undeleted messages
|
|
$messages = $this->size();
|
|
|
|
for ($x = 0; $x < $messages; $x++) {
|
|
if (in_array($x, $message)) {
|
|
continue;
|
|
}
|
|
|
|
$messageThis = $this->_escapeMessage($this->get($x));
|
|
if (is_string($messageThis)) {
|
|
fwrite($ftemp, $messageThis, strlen($messageThis));
|
|
}
|
|
}
|
|
|
|
// closing file
|
|
$this->close();
|
|
fclose($ftemp);
|
|
|
|
return $this->_move($ftempname, $this->_file);
|
|
}
|
|
|
|
/**
|
|
* Update a message
|
|
*
|
|
* Note: messages start with 0.
|
|
*
|
|
* @param int $message The number of Message to update
|
|
* @param string $content The new content of the Message
|
|
*
|
|
* @return mixed Return true if all is ok, else PEAR_Error
|
|
* @access public
|
|
*/
|
|
function update($message, $content)
|
|
{
|
|
if (!$this->_isValid($content)) {
|
|
return PEAR::raiseError(
|
|
'Message is invalid', MAIL_MBOX_ERROR_MSG_INVALID
|
|
);
|
|
}
|
|
|
|
if ($this->hasBeenModified()) {
|
|
return PEAR::raiseError(
|
|
'File has been modified since loading. Re-open the file.',
|
|
MAIL_MBOX_ERROR_MODIFIED
|
|
);
|
|
}
|
|
|
|
// checking if we have bytes locations for this message
|
|
if (!is_array($this->_index[$message])) {
|
|
return PEAR::raiseError(
|
|
'Message does not exist.',
|
|
MAIL_MBOX_ERROR_MESSAGE_NOT_EXISTING
|
|
);
|
|
}
|
|
|
|
// creating temp file
|
|
$ftempname = tempnam($this->tmpdir, 'Mail_Mbox');
|
|
$ftemp = fopen($ftempname, 'w');
|
|
if ($ftemp === false) {
|
|
return PEAR::raiseError(
|
|
'Cannot create temp file "' . $ftempname . '" .',
|
|
MAIL_MBOX_ERROR_CANNOT_CREATE_TMP
|
|
);
|
|
}
|
|
|
|
$messages = $this->size();
|
|
|
|
for ($x = 0; $x < $messages; $x++) {
|
|
if ($x == $message) {
|
|
$messageThis = $content;
|
|
} else {
|
|
$messageThis = $this->get($x);
|
|
}
|
|
|
|
if (is_string($messageThis)) {
|
|
$messageThis = $this->_escapeMessage($messageThis);
|
|
fwrite($ftemp, $messageThis, strlen($messageThis));
|
|
}
|
|
}
|
|
|
|
// closing file
|
|
$this->close();
|
|
fclose($ftemp);
|
|
|
|
return $this->_move($ftempname, $this->_file);
|
|
}
|
|
|
|
/**
|
|
* Insert a message
|
|
*
|
|
* PEAR::Mail_Mbox will insert the message according its offset.
|
|
* 0 means before the actual message 0. 3 means before the message 3
|
|
* (Remember: message 3 is the fourth message). The default is put
|
|
* AFTER the last message (offset = null).
|
|
*
|
|
* @param string $content The content of the new message
|
|
* @param int $offset Before the offset. Default: last message (null)
|
|
*
|
|
* @return mixed Return true else PEAR_Error object
|
|
* @access public
|
|
*/
|
|
function insert($content, $offset = null)
|
|
{
|
|
if (!$this->_isValid($content)) {
|
|
return PEAR::raiseError(
|
|
'Message is invalid', MAIL_MBOX_ERROR_MSG_INVALID
|
|
);
|
|
}
|
|
|
|
if ($this->hasBeenModified()) {
|
|
return PEAR::raiseError(
|
|
'File has been modified since loading. Re-open the file.',
|
|
MAIL_MBOX_ERROR_MODIFIED
|
|
);
|
|
}
|
|
|
|
// optimize insert() to use append whenever possible
|
|
if ($offset < 0 || $offset == $this->size() || $this->size() == 0) {
|
|
return $this->append($content);
|
|
}
|
|
|
|
// creating temp file
|
|
$ftempname = tempnam($this->tmpdir, 'Mail_Mbox');
|
|
$ftemp = fopen($ftempname, 'w');
|
|
if ($ftemp === false) {
|
|
return PEAR::raiseError(
|
|
'Cannot create temp file "' . $ftempname . '".',
|
|
MAIL_MBOX_ERROR_CANNOT_CREATE_TMP
|
|
);
|
|
}
|
|
|
|
// writing only undeleted messages
|
|
$messages = $this->size();
|
|
$content = $this->_escapeMessage($content);
|
|
|
|
if ($messages == 0 && $offset !== null) {
|
|
fwrite($ftemp, $content, strlen($content));
|
|
} else {
|
|
for ($x = 0; $x < $messages; $x++) {
|
|
if ($offset !== null && $x == $offset) {
|
|
fwrite($ftemp, $content, strlen($content));
|
|
}
|
|
$messageThis = $this->_escapeMessage($this->get($x));
|
|
|
|
if (is_string($messageThis)) {
|
|
fwrite($ftemp, $messageThis, strlen($messageThis));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($offset === null) {
|
|
fwrite($ftemp, $content, strlen($content));
|
|
}
|
|
|
|
// closing file
|
|
$this->close();
|
|
fclose($ftemp);
|
|
|
|
return $this->_move($ftempname, $this->_file);
|
|
}
|
|
|
|
/**
|
|
* Appends a message at the end of the file.
|
|
*
|
|
* This method is also used by insert() since it's faster.
|
|
*
|
|
* @param string $content The content of the new message
|
|
*
|
|
* @return mixed Return true else PEAR_Error object
|
|
* @access public
|
|
*/
|
|
function append($content)
|
|
{
|
|
if (!$this->_isValid($content)) {
|
|
return PEAR::raiseError(
|
|
'Message is invalid', MAIL_MBOX_ERROR_MSG_INVALID
|
|
);
|
|
}
|
|
|
|
$this->close();
|
|
$content = $this->_escapeMessage($content);
|
|
|
|
$fp = fopen($this->_file, 'a');
|
|
if ($fp === false) {
|
|
return PEAR::raiseError(
|
|
'Cannot open file "' . $this->_file . '" for appending.',
|
|
MAIL_MBOX_ERROR_CANNOT_OPEN
|
|
);
|
|
}
|
|
|
|
if (fwrite($fp, $content, strlen($content)) === false) {
|
|
return PEAR::raiseError(
|
|
'Cannot write to file "' . $this->_file. '".',
|
|
MAIL_MBOX_ERROR_CANNOT_WRITE
|
|
);
|
|
}
|
|
|
|
return $this->_reopen();
|
|
}
|
|
|
|
/**
|
|
* Checks if the given message is valid.
|
|
* If it was invalid and we'd add it to the file,
|
|
* it would get unreadable
|
|
*
|
|
* @param string $content Message to be added or updated
|
|
*
|
|
* @return boolean True if it is valid, false if not
|
|
*/
|
|
function _isValid($content)
|
|
{
|
|
if (substr($content, 0, 5) != 'From ') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Move a file to another.
|
|
*
|
|
* Used internally to move the content of the temp file to the mbox file.
|
|
* Note that we can't use rename() internally, as it behaves very, very
|
|
* strange on windows.
|
|
*
|
|
* @param string $ftempname Source file - will be removed
|
|
* @param string $filename Output file
|
|
*
|
|
* @return boolean|PEAR_Error True if everything went fine, PEAR_Error when
|
|
* an error happened.
|
|
* @access protected
|
|
*/
|
|
function _move($ftempname, $filename)
|
|
{
|
|
if (!copy($ftempname, $filename)) {
|
|
return PEAR::raiseError(
|
|
'Cannot copy "' . $ftempname . '" to "' . $filename . '".',
|
|
MAIL_MBOX_ERROR_CANNOT_WRITE
|
|
);
|
|
}
|
|
|
|
unlink($ftempname);
|
|
|
|
// open another resource and substitute it to the old one
|
|
$this->_file = $filename;
|
|
return $this->_reopen();
|
|
}
|
|
|
|
/**
|
|
* Process the Mbox
|
|
*
|
|
* Put start bytes and end bytes of each message into _index array
|
|
*
|
|
* @return boolean|PEAR_Error True if all went ok, PEAR_Error on failure
|
|
* @access protected
|
|
*/
|
|
function _process()
|
|
{
|
|
$this->_index = array();
|
|
|
|
// sanity check
|
|
if (!is_resource($this->_resource)) {
|
|
return PEAR::raiseError(
|
|
'Resource is not valid. Maybe the file has not be opened?',
|
|
MAIL_MBOX_ERROR_NOT_OPEN
|
|
);
|
|
}
|
|
|
|
// going to start
|
|
if (fseek($this->_resource, 0) == -1) {
|
|
return PEAR::raiseError(
|
|
'Cannot read mbox',
|
|
MAIL_MBOX_ERROR_CANNOT_READ
|
|
);
|
|
}
|
|
|
|
// current start byte position
|
|
$start = 0;
|
|
// last start byte position
|
|
$laststart = 0;
|
|
// there aren't any message
|
|
$hasmessage = false;
|
|
|
|
while ($line = fgets($this->_resource, 4096)) {
|
|
// if line start with "From ", it is a new message
|
|
if (0 === strncmp($line, 'From ', 5)) {
|
|
// save last start byte position
|
|
$laststart = $start;
|
|
|
|
// new start byte position is the start of the line
|
|
$start = ftell($this->_resource) - strlen($line);
|
|
|
|
// if it is not the first message add message positions
|
|
if ($start > 0) {
|
|
$this->_index[] = array($laststart, $start - 1);
|
|
} else {
|
|
// tell that there is really a message on the file
|
|
$hasmessage = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if there are just one message, or if it's the last one,
|
|
// add it to messages positions
|
|
if (($start == 0 && $hasmessage === true) || ($start > 0)) {
|
|
$this->_index[] = array($start, ftell($this->_resource));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Quotes "From " lines in the midst of the message.
|
|
* And quoted "From " lines, too :)
|
|
* Also appends the trailing newline.
|
|
* After escaping, the message can be written to file.
|
|
*
|
|
* @param string $message Message content
|
|
*
|
|
* @return string Escaped message
|
|
*
|
|
* @access protected
|
|
* @see _unescapeMessage()
|
|
*/
|
|
function _escapeMessage($message)
|
|
{
|
|
if (substr($message, -1) == "\n") {
|
|
$message .= "\n";
|
|
} else {
|
|
$message .= "\n\n";
|
|
}
|
|
return preg_replace(
|
|
"/\n([>]*From )/",
|
|
"\n>$1",
|
|
$message
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Removes quoted "From " lines from the message
|
|
*
|
|
* @param string $message Message content
|
|
*
|
|
* @return string Unescaped message
|
|
*
|
|
* @access protected
|
|
* @see _escapeMessage()
|
|
*/
|
|
function _unescapeMessage($message)
|
|
{
|
|
return preg_replace(
|
|
"/\n>([>]*From )/",
|
|
"\n$1",
|
|
//the -1 drops the last newline
|
|
substr($message, 0, -1)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Checks if the file was modified since it has been loaded.
|
|
* If this is true, the file needs to be re-opened.
|
|
*
|
|
* @return bool True if it has been modified.
|
|
* @access public
|
|
*/
|
|
function hasBeenModified()
|
|
{
|
|
return filemtime($this->_file) > $this->_lastModified;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Dumb getter and setter
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
* Set the directory for temporary files.
|
|
*
|
|
* @param string $tmpdir The new temporary directory
|
|
*
|
|
* @return mixed True if all is ok, PEAR_Error if $tmpdir
|
|
* is a dir but not writable
|
|
*
|
|
* @see Mail_Mbox::$tmpdir
|
|
*/
|
|
function setTmpDir($tmpdir)
|
|
{
|
|
if (is_dir($tmpdir) && !is_writable($tmpdir)) {
|
|
return PEAR::raiseError(
|
|
'"' . $tmpdir . '" is not writable.',
|
|
MAIL_MBOX_ERROR_CANNOT_WRITE
|
|
);
|
|
} else {
|
|
$this->tmpdir = $tmpdir;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the temporary directory
|
|
*
|
|
* @return string The temporary directory
|
|
*/
|
|
function getTmpDir()
|
|
{
|
|
return $this->tmpdir;
|
|
}
|
|
|
|
/**
|
|
* Set the debug flag
|
|
*
|
|
* @param bool $debug If debug is on or off
|
|
*
|
|
* @return void
|
|
* @see Mail_Mbox::$debug
|
|
*/
|
|
function setDebug($debug)
|
|
{
|
|
$this->debug = (bool)$debug;
|
|
}
|
|
|
|
/**
|
|
* Returns the debug flag setting
|
|
*
|
|
* @see Mail_Mbox::$debug
|
|
*
|
|
* @return bool If debug is enabled.
|
|
*/
|
|
function getDebug()
|
|
{
|
|
return $this->debug;
|
|
}
|
|
|
|
/**
|
|
* Sets if the mbox is reloaded after modification
|
|
* automatically.
|
|
*
|
|
* @param bool $autoReopen If the mbox is reloaded automatically
|
|
*
|
|
* @return void
|
|
* @see Mail_Mbox::$autoReopen
|
|
*/
|
|
function setAutoReopen($autoReopen)
|
|
{
|
|
$this->autoReopen = (bool)$autoReopen;
|
|
}
|
|
|
|
/**
|
|
* Returns the automatically reopening setting
|
|
*
|
|
* @return bool If the mbox is reloaded automatically.
|
|
*
|
|
* @see Mail_Mbox::$autoReopen
|
|
*/
|
|
function getAutoReopen()
|
|
{
|
|
return $this->autoReopen;
|
|
}
|
|
}
|
|
?>
|