446 lines
16 KiB
Python
Executable file
446 lines
16 KiB
Python
Executable file
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# SàT plugin for managing imap server
|
|
# Copyright (C) 2011 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from sat.core.i18n import _
|
|
from sat.core.log import getLogger
|
|
log = getLogger(__name__)
|
|
from twisted.internet import protocol, defer
|
|
from twisted.cred import portal, checkers, credentials
|
|
from twisted.cred import error as cred_error
|
|
from twisted.mail import imap4
|
|
from twisted.python import failure
|
|
from email.parser import Parser
|
|
import os
|
|
from cStringIO import StringIO
|
|
from twisted.internet import reactor
|
|
|
|
from zope.interface import implements
|
|
|
|
PLUGIN_INFO = {
|
|
"name": "IMAP server Plugin",
|
|
"import_name": "IMAP",
|
|
"type": "Misc",
|
|
"protocols": [],
|
|
"dependencies": ["Maildir"],
|
|
"main": "IMAP_server",
|
|
"handler": "no",
|
|
"description": _("""Create an Imap server that you can use to read your "normal" type messages""")
|
|
}
|
|
|
|
|
|
class IMAP_server(object):
|
|
#TODO: connect profile on mailbox request, once password is accepted
|
|
|
|
params = """
|
|
<params>
|
|
<general>
|
|
<category name="Mail Server">
|
|
<param name="IMAP Port" value="10143" type="int" constraint="1;65535" />
|
|
</category>
|
|
</general>
|
|
</params>
|
|
"""
|
|
|
|
def __init__(self, host):
|
|
log.info(_("Plugin Imap Server initialization"))
|
|
self.host = host
|
|
|
|
#parameters
|
|
host.memory.updateParams(self.params)
|
|
|
|
port = int(self.host.memory.getParamA("IMAP Port", "Mail Server"))
|
|
log.info(_("Launching IMAP server on port %d") % port)
|
|
|
|
self.server_factory = ImapServerFactory(self.host)
|
|
reactor.listenTCP(port, self.server_factory)
|
|
|
|
|
|
class Message(object):
|
|
implements(imap4.IMessage)
|
|
|
|
def __init__(self, uid, flags, mess_fp):
|
|
log.debug('Message Init')
|
|
self.uid = uid
|
|
self.flags = flags
|
|
self.mess_fp = mess_fp
|
|
self.message = Parser().parse(mess_fp)
|
|
|
|
def getUID(self):
|
|
"""Retrieve the unique identifier associated with this message.
|
|
"""
|
|
log.debug('getUID (message)')
|
|
return self.uid
|
|
|
|
def getFlags(self):
|
|
"""Retrieve the flags associated with this message.
|
|
@return: The flags, represented as strings.
|
|
"""
|
|
log.debug('getFlags')
|
|
return self.flags
|
|
|
|
def getInternalDate(self):
|
|
"""Retrieve the date internally associated with this message.
|
|
@return: An RFC822-formatted date string.
|
|
"""
|
|
log.debug('getInternalDate')
|
|
return self.message['Date']
|
|
|
|
def getHeaders(self, negate, *names):
|
|
"""Retrieve a group of message headers.
|
|
@param names: The names of the headers to retrieve or omit.
|
|
@param negate: If True, indicates that the headers listed in names
|
|
should be omitted from the return value, rather than included.
|
|
@return: A mapping of header field names to header field values
|
|
"""
|
|
log.debug('getHeaders %s - %s' % (negate, names))
|
|
final_dict = {}
|
|
to_check = [name.lower() for name in names]
|
|
for header in self.message.keys():
|
|
if (negate and not header.lower() in to_check) or \
|
|
(not negate and header.lower() in to_check):
|
|
final_dict[header] = self.message[header]
|
|
return final_dict
|
|
|
|
def getBodyFile(self):
|
|
"""Retrieve a file object containing only the body of this message.
|
|
"""
|
|
log.debug('getBodyFile')
|
|
return StringIO(self.message.get_payload())
|
|
|
|
def getSize(self):
|
|
"""Retrieve the total size, in octets, of this message.
|
|
"""
|
|
log.debug('getSize')
|
|
self.mess_fp.seek(0, os.SEEK_END)
|
|
return self.mess_fp.tell()
|
|
|
|
def isMultipart(self):
|
|
"""Indicate whether this message has subparts.
|
|
"""
|
|
log.debug('isMultipart')
|
|
return False
|
|
|
|
def getSubPart(self, part):
|
|
"""Retrieve a MIME sub-message
|
|
@param part: The number of the part to retrieve, indexed from 0.
|
|
@return: The specified sub-part.
|
|
"""
|
|
log.debug('getSubPart')
|
|
return TypeError
|
|
|
|
|
|
class SatMailbox(object):
|
|
implements(imap4.IMailbox)
|
|
|
|
def __init__(self, host, name, profile):
|
|
self.host = host
|
|
self.listeners = set()
|
|
log.debug('Mailbox init (%s)' % name)
|
|
if name != "INBOX":
|
|
raise imap4.MailboxException("Only INBOX is managed for the moment")
|
|
self.mailbox = self.host.plugins["Maildir"].accessMessageBox(name, self.newMessage, profile)
|
|
|
|
def newMessage(self):
|
|
"""Called when a new message is in the mailbox"""
|
|
log.debug("newMessage signal received")
|
|
nb_messages = self.getMessageCount()
|
|
for listener in self.listeners:
|
|
listener.newMessages(nb_messages, None)
|
|
|
|
def getUIDValidity(self):
|
|
"""Return the unique validity identifier for this mailbox.
|
|
"""
|
|
log.debug('getUIDValidity')
|
|
return 0
|
|
|
|
def getUIDNext(self):
|
|
"""Return the likely UID for the next message added to this mailbox.
|
|
"""
|
|
log.debug('getUIDNext')
|
|
return self.mailbox.getNextUid()
|
|
|
|
def getUID(self, message):
|
|
"""Return the UID of a message in the mailbox
|
|
@param message: The message sequence number
|
|
@return: The UID of the message.
|
|
"""
|
|
log.debug('getUID (%i)' % message)
|
|
#return self.mailbox.getUid(message-1) #XXX: it seems that this method get uid and not message sequence number
|
|
return message
|
|
|
|
def getMessageCount(self):
|
|
"""Return the number of messages in this mailbox.
|
|
"""
|
|
log.debug('getMessageCount')
|
|
ret = self.mailbox.getMessageCount()
|
|
log.debug("count = %i" % ret)
|
|
return ret
|
|
|
|
def getRecentCount(self):
|
|
"""Return the number of messages with the 'Recent' flag.
|
|
"""
|
|
log.debug('getRecentCount')
|
|
return len(self.mailbox.getMessageIdsWithFlag('\\Recent'))
|
|
|
|
def getUnseenCount(self):
|
|
"""Return the number of messages with the 'Unseen' flag.
|
|
"""
|
|
log.debug('getUnseenCount')
|
|
return self.getMessageCount() - len(self.mailbox.getMessageIdsWithFlag('\\SEEN'))
|
|
|
|
def isWriteable(self):
|
|
"""Get the read/write status of the mailbox.
|
|
@return: A true value if write permission is allowed, a false value otherwise.
|
|
"""
|
|
log.debug('isWriteable')
|
|
return True
|
|
|
|
def destroy(self):
|
|
"""Called before this mailbox is deleted, permanently.
|
|
"""
|
|
log.debug('destroy')
|
|
|
|
def requestStatus(self, names):
|
|
"""Return status information about this mailbox.
|
|
@param names: The status names to return information regarding.
|
|
The possible values for each name are: MESSAGES, RECENT, UIDNEXT,
|
|
UIDVALIDITY, UNSEEN.
|
|
@return: A dictionary containing status information about the
|
|
requested names is returned. If the process of looking this
|
|
information up would be costly, a deferred whose callback will
|
|
eventually be passed this dictionary is returned instead.
|
|
"""
|
|
log.debug('requestStatus')
|
|
return imap4.statusRequestHelper(self, names)
|
|
|
|
def addListener(self, listener):
|
|
"""Add a mailbox change listener
|
|
|
|
@type listener: Any object which implements C{IMailboxListener}
|
|
@param listener: An object to add to the set of those which will
|
|
be notified when the contents of this mailbox change.
|
|
"""
|
|
log.debug('addListener %s' % listener)
|
|
self.listeners.add(listener)
|
|
|
|
def removeListener(self, listener):
|
|
"""Remove a mailbox change listener
|
|
|
|
@type listener: Any object previously added to and not removed from
|
|
this mailbox as a listener.
|
|
@param listener: The object to remove from the set of listeners.
|
|
|
|
@raise ValueError: Raised when the given object is not a listener for
|
|
this mailbox.
|
|
"""
|
|
log.debug('removeListener')
|
|
if listener in self.listeners:
|
|
self.listeners.remove(listener)
|
|
else:
|
|
raise imap4.MailboxException('Trying to remove an unknown listener')
|
|
|
|
def addMessage(self, message, flags=(), date=None):
|
|
"""Add the given message to this mailbox.
|
|
@param message: The RFC822 formatted message
|
|
@param flags: The flags to associate with this message
|
|
@param date: If specified, the date to associate with this
|
|
@return: A deferred whose callback is invoked with the message
|
|
id if the message is added successfully and whose errback is
|
|
invoked otherwise.
|
|
"""
|
|
log.debug('addMessage')
|
|
raise imap4.MailboxException("Client message addition not implemented yet")
|
|
|
|
def expunge(self):
|
|
"""Remove all messages flagged \\Deleted.
|
|
@return: The list of message sequence numbers which were deleted,
|
|
or a Deferred whose callback will be invoked with such a list.
|
|
"""
|
|
log.debug('expunge')
|
|
self.mailbox.removeDeleted()
|
|
|
|
def fetch(self, messages, uid):
|
|
"""Retrieve one or more messages.
|
|
@param messages: The identifiers of messages to retrieve information
|
|
about
|
|
@param uid: If true, the IDs specified in the query are UIDs;
|
|
"""
|
|
log.debug('fetch (%s, %s)' % (messages, uid))
|
|
if uid:
|
|
messages.last = self.mailbox.getMaxUid()
|
|
messages.getnext = self.mailbox.getNextExistingUid
|
|
for mess_uid in messages:
|
|
if mess_uid is None:
|
|
log.debug('stopping iteration')
|
|
raise StopIteration
|
|
try:
|
|
yield (mess_uid, Message(mess_uid, self.mailbox.getFlagsUid(mess_uid), self.mailbox.getMessageUid(mess_uid)))
|
|
except IndexError:
|
|
continue
|
|
else:
|
|
messages.last = self.getMessageCount()
|
|
for mess_idx in messages:
|
|
if mess_idx > self.getMessageCount():
|
|
raise StopIteration
|
|
yield (mess_idx, Message(mess_idx, self.mailbox.getFlags(mess_idx), self.mailbox.getMessage(mess_idx - 1)))
|
|
|
|
def store(self, messages, flags, mode, uid):
|
|
"""Set the flags of one or more messages.
|
|
@param messages: The identifiers of the messages to set the flags of.
|
|
@param flags: The flags to set, unset, or add.
|
|
@param mode: If mode is -1, these flags should be removed from the
|
|
specified messages. If mode is 1, these flags should be added to
|
|
the specified messages. If mode is 0, all existing flags should be
|
|
cleared and these flags should be added.
|
|
@param uid: If true, the IDs specified in the query are UIDs;
|
|
otherwise they are message sequence IDs.
|
|
@return: A dict mapping message sequence numbers to sequences of str
|
|
representing the flags set on the message after this operation has
|
|
been performed, or a Deferred whose callback will be invoked with
|
|
such a dict.
|
|
"""
|
|
log.debug('store')
|
|
|
|
flags = [flag.upper() for flag in flags]
|
|
|
|
def updateFlags(getF, setF):
|
|
ret = {}
|
|
for mess_id in messages:
|
|
if (uid and mess_id is None) or (not uid and mess_id > self.getMessageCount()):
|
|
break
|
|
_flags = set(getF(mess_id) if mode else [])
|
|
if mode == -1:
|
|
_flags.difference_update(set(flags))
|
|
else:
|
|
_flags.update(set(flags))
|
|
new_flags = list(_flags)
|
|
setF(mess_id, new_flags)
|
|
ret[mess_id] = tuple(new_flags)
|
|
return ret
|
|
|
|
if uid:
|
|
messages.last = self.mailbox.getMaxUid()
|
|
messages.getnext = self.mailbox.getNextExistingUid
|
|
ret = updateFlags(self.mailbox.getFlagsUid, self.mailbox.setFlagsUid)
|
|
for listener in self.listeners:
|
|
listener.flagsChanged(ret)
|
|
return ret
|
|
|
|
else:
|
|
messages.last = self.getMessageCount()
|
|
ret = updateFlags(self.mailbox.getFlags, self.mailbox.setFlags)
|
|
newFlags = {}
|
|
for idx in ret:
|
|
#we have to convert idx to uid for the listeners
|
|
newFlags[self.mailbox.getUid(idx)] = ret[idx]
|
|
for listener in self.listeners:
|
|
listener.flagsChanged(newFlags)
|
|
return ret
|
|
|
|
def getFlags(self):
|
|
"""Return the flags defined in this mailbox
|
|
Flags with the \\ prefix are reserved for use as system flags.
|
|
@return: A list of the flags that can be set on messages in this mailbox.
|
|
"""
|
|
log.debug('getFlags')
|
|
return ['\\SEEN', '\\ANSWERED', '\\FLAGGED', '\\DELETED', '\\DRAFT'] # TODO: add '\\RECENT'
|
|
|
|
def getHierarchicalDelimiter(self):
|
|
"""Get the character which delimits namespaces for in this mailbox.
|
|
"""
|
|
log.debug('getHierarchicalDelimiter')
|
|
return '.'
|
|
|
|
|
|
class ImapSatAccount(imap4.MemoryAccount):
|
|
#implements(imap4.IAccount)
|
|
|
|
def __init__(self, host, profile):
|
|
log.debug("ImapAccount init")
|
|
self.host = host
|
|
self.profile = profile
|
|
imap4.MemoryAccount.__init__(self, profile)
|
|
self.addMailbox("Inbox") # We only manage Inbox for the moment
|
|
log.debug('INBOX added')
|
|
|
|
def _emptyMailbox(self, name, id):
|
|
return SatMailbox(self.host, name, self.profile)
|
|
|
|
|
|
class ImapRealm(object):
|
|
implements(portal.IRealm)
|
|
|
|
def __init__(self, host):
|
|
self.host = host
|
|
|
|
def requestAvatar(self, avatarID, mind, *interfaces):
|
|
log.debug('requestAvatar')
|
|
profile = avatarID.decode('utf-8')
|
|
if imap4.IAccount not in interfaces:
|
|
raise NotImplementedError
|
|
return imap4.IAccount, ImapSatAccount(self.host, profile), lambda: None
|
|
|
|
|
|
class SatProfileCredentialChecker(object):
|
|
"""
|
|
This credential checker check against SàT's profile and associated jabber's password
|
|
Check if the profile exists, and if the password is OK
|
|
Return the profile as avatarId
|
|
"""
|
|
implements(checkers.ICredentialsChecker)
|
|
credentialInterfaces = (credentials.IUsernamePassword,
|
|
credentials.IUsernameHashedPassword)
|
|
|
|
def __init__(self, host):
|
|
self.host = host
|
|
|
|
def _cbPasswordMatch(self, matched, profile):
|
|
if matched:
|
|
return profile.encode('utf-8')
|
|
else:
|
|
return failure.Failure(cred_error.UnauthorizedLogin())
|
|
|
|
def requestAvatarId(self, credentials):
|
|
profiles = self.host.memory.getProfilesList()
|
|
if not credentials.username in profiles:
|
|
return defer.fail(cred_error.UnauthorizedLogin())
|
|
d = self.host.memory.asyncGetParamA("Password", "Connection", profile_key=credentials.username)
|
|
d.addCallback(lambda password: credentials.checkPassword(password))
|
|
d.addCallback(self._cbPasswordMatch, credentials.username)
|
|
return d
|
|
|
|
|
|
class ImapServerFactory(protocol.ServerFactory):
|
|
protocol = imap4.IMAP4Server
|
|
|
|
def __init__(self, host):
|
|
self.host = host
|
|
|
|
def startedConnecting(self, connector):
|
|
log.debug(_("IMAP server connection started"))
|
|
|
|
def clientConnectionLost(self, connector, reason):
|
|
log.debug(_("IMAP server connection lost (reason: %s)"), reason)
|
|
|
|
def buildProtocol(self, addr):
|
|
log.debug("Building protocol")
|
|
prot = protocol.ServerFactory.buildProtocol(self, addr)
|
|
prot.portal = portal.Portal(ImapRealm(self.host))
|
|
prot.portal.registerChecker(SatProfileCredentialChecker(self.host))
|
|
return prot
|