## ## component.py ## Login : David Rousselie ## Started on Fri Jan 7 11:06:42 2005 ## $Id: component.py,v 1.12 2005/09/18 20:24:07 dax Exp $ ## ## Copyright (C) 2005 ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 2 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 General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, write to the Free Software ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ## import re import signal import threading import logging import sys import anydbm import os import mailconnection from mailconnection import * from x import * from storage import * import mailconnection_factory import pyxmpp.jabberd from pyxmpp.presence import Presence from pyxmpp.message import Message from pyxmpp.streambase import StreamError, FatalStreamError from pyxmpp.jid import JID from pyxmpp.jabber.disco import DiscoItems, DiscoItem, DiscoInfo, DiscoIdentity from pyxmpp.jabberd.component import Component class ComponentFatalError(RuntimeError): pass class MailComponent(Component): def __init__(self, config): Component.__init__(self, \ JID(config.get_content("config/jabber/service")), \ config.get_content("config/jabber/secret"), \ config.get_content("config/jabber/server"), \ int(config.get_content("config/jabber/port")), \ disco_category = "gateway", \ disco_type = "headline") self.__logger = logging.getLogger("jabber.Component") self.__shutdown = 0 # TODO : delete signals not known by Windows signal.signal(signal.SIGINT, self.signal_handler) signal.signal(signal.SIGPIPE, self.signal_handler) signal.signal(signal.SIGHUP, self.signal_handler) signal.signal(signal.SIGTERM, self.signal_handler) signal.signal(signal.SIGALRM, self.time_handler) self.__interval = int(config.get_content("config/check_interval")) self.__config = config try: self.__storage = globals()[config.get_content("config/storage") + "Storage"]() except: print >>sys.stderr, "Cannot find " \ + config.get_content("config/storage") + "Storage class" exit(1) self.__spool_dir = config.get_content("config/spooldir") + "/" + \ config.get_content("config/jabber/service") self.__storage.spool_dir = self.__spool_dir self.__storage.nb_pk_fields = 2 self.__reg_form = None self.__reg_form_init = None # dump registered accounts (save) at least every hour self.__count = 60 / self.__interval def __del__(self): logging.shutdown() """ Register Form creator """ def get_reg_form(self): if self.__reg_form == None: self.__reg_form = X() self.__reg_form.xmlns = "jabber:x:data" self.__reg_form.title = "Jabber Mail connection registration" self.__reg_form.instructions = "Enter anything below" self.__reg_form.type = "form" self.__reg_form.add_field(type = "text-single", \ label = "Connection name", \ var = "name") self.__reg_form.add_field(type = "text-single", \ label = "Login", \ var = "login") self.__reg_form.add_field(type = "text-private", \ label = "Password", \ var = "password") self.__reg_form.add_field(type = "text-single", \ label = "Host", \ var = "host") self.__reg_form.add_field(type = "text-single", \ label = "Port", \ var = "port") field = self.__reg_form.add_field(type = "list-single", \ label = "Mailbox type", \ var = "type") field.add_option(label = "POP3", \ value = "pop3") field.add_option(label = "POP3S", \ value = "pop3s") field.add_option(label = "IMAP", \ value = "imap") field.add_option(label = "IMAPS", \ value = "imaps") self.__reg_form.add_field(type = "text-single", \ label = "Mailbox (IMAP)", \ var = "mailbox", \ value = "INBOX") field = self.__reg_form.add_field(type = "list-single", \ label = "Action when state is 'Free For Chat'", \ var = "chat_action", \ value = str(mailconnection.RETRIEVE)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form.add_field(type = "list-single", \ label = "Action when state is 'Online'", \ var = "online_action", \ value = str(mailconnection.RETRIEVE)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form.add_field(type = "list-single", \ label = "Action when state is 'Away'", \ var = "away_action", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form.add_field(type = "list-single", \ label = "Action when state is 'Not Available'", \ var = "xa_action", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form.add_field(type = "list-single", \ label = "Action when state is 'Do not Disturb'", \ var = "dnd_action", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form.add_field(type = "list-single", \ label = "Action when state is 'Offline'", \ var = "offline_action", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) # default interval in config file self.__reg_form.add_field(type = "text-single", \ label = "Mail check interval (in minutes)", \ var = "interval", \ value = "5") return self.__reg_form """ Register Form modifier for existing accounts """ def get_reg_form_init(self, jid, name): if not self.__storage.has_key((jid, name)): return None account = self.__storage[(jid, name)] if self.__reg_form_init == None: self.__reg_form_init = X() self.__reg_form_init.xmlns = "jabber:x:data" self.__reg_form_init.title = "Jabber mail connection Modifier" self.__reg_form_init.instructions = "Modifier for connection " + \ name self.__reg_form_init.type = "form" self.__reg_form_init.add_field(type = "fixed", \ label = "Connection name", \ var = "name", \ value = name) self.__reg_form_init.add_field(type = "text-single", \ label = "Login", \ var = "login", \ value = account.login) self.__reg_form_init.add_field(type = "text-private", \ label = "Password", \ var = "password", \ value = account.password) self.__reg_form_init.add_field(type = "text-single", \ label = "Host", \ var = "host", \ value = account.host) self.__reg_form_init.add_field(type = "text-single", \ label = "Port", \ var = "port", \ value = str(account.port)) field = self.__reg_form_init.add_field(type = "list-single", \ label = "Mailbox type", \ var = "type", \ value = account.get_type()) field.add_option(label = "POP3", \ value = "pop3") field.add_option(label = "POP3S", \ value = "pop3s") field.add_option(label = "IMAP", \ value = "imap") field.add_option(label = "IMAPS", \ value = "imaps") self.__reg_form_init.add_field(type = "text-single", \ label = "Mailbox (IMAP)", \ var = "mailbox") field = self.__reg_form_init.add_field(type = "list-single", \ label = "Action when state is 'Free For Chat'", \ var = "chat_action", \ value = str(account.chat_action)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form_init.add_field(type = "list-single", \ label = "Action when state is 'Online'", \ var = "online_action", \ value = str(account.online_action)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form_init.add_field(type = "list-single", \ label = "Action when state is 'Away'", \ var = "away_action", \ value = str(account.away_action)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form_init.add_field(type = "list-single", \ label = "Action when state is 'Not Available'", \ var = "xa_action", \ value = str(account.xa_action)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form_init.add_field(type = "list-single", \ label = "Action when state is 'Do not Disturb'", \ var = "dnd_action", \ value = str(account.dnd_action)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) field = self.__reg_form_init.add_field(type = "list-single", \ label = "Action when state is 'Offline'", \ var = "offline_action", \ value = str(account.offline_action)) field.add_option(label = "Do nothing", \ value = str(mailconnection.DO_NOTHING)) field.add_option(label = "Send mail digest", \ value = str(mailconnection.DIGEST)) field.add_option(label = "Retrieve mail", \ value = str(mailconnection.RETRIEVE)) self.__reg_form_init.add_field(type = "text-single", \ label = "Mail check interval (in minutes)", \ var = "interval", \ value = str(account.interval)) else: self.__reg_form_init.fields["login"].value = account.login self.__reg_form_init.fields["password"].value = account.password self.__reg_form_init.fields["host"].value = account.host self.__reg_form_init.fields["port"].value = str(account.port) self.__reg_form_init.fields["type"].value = account.get_type() self.__reg_form_init.fields["chat_action"].value = str(account.chat_action) self.__reg_form_init.fields["online_action"].value = str(account.online_action) self.__reg_form_init.fields["away_action"].value = str(account.away_action) self.__reg_form_init.fields["xa_action"].value = str(account.xa_action) self.__reg_form_init.fields["dnd_action"].value = str(account.dnd_action) self.__reg_form_init.fields["offline_action"].value = str(account.offline_action) self.__reg_form_init.fields["interval"].value = str(account.interval) if account.get_type()[0:4] == "imap": self.__reg_form_init.fields["mailbox"].value = account.mailbox else: self.__reg_form_init.fields["mailbox"].value = "INBOX" return self.__reg_form_init """ Looping method """ def run(self, timeout): self.connect() # Set check mail timer threading.Timer(self.__interval * 60, self.time_handler) try: while (not self.__shutdown and self.stream and not self.stream.eof and self.stream.socket is not None): try: self.stream.loop_iter(timeout) except (KeyboardInterrupt, SystemExit, FatalStreamError, \ StreamError): raise except: self.__logger.exception("Exception cought:") finally: ## TODO : for jid in self.__storage.keys(()) ## for name in self.__storage.keys((jid,)) if self.stream: for jid in self.__storage.keys(()): p = Presence(from_jid = unicode(self.jid), to_jid = jid, \ stanza_type = "unavailable") self.stream.send(p) for jid, name in self.__storage.keys(): if self.__storage[(jid, name)].status != "offline": p = Presence(from_jid = name + "@" + unicode(self.jid), \ to_jid = jid, \ stanza_type = "unavailable") self.stream.send(p) threads = threading.enumerate() for th in threads: try: th.join(10 * timeout) except: pass for th in threads: try: th.join(timeout) except: pass self.disconnect() del self.__storage self.__logger.debug("Exitting normally") """ Stop method handler """ def signal_handler(self, signum, frame): self.__logger.debug("Signal %i received, shutting down..." % (signum,)) self.__shutdown = 1 """ SIGALRM signal handler """ def time_handler(self, signum, frame): self.__logger.debug("Signal %i received, checking mail..." % (signum,)) self.check_all_mail() self.__logger.debug("Resetting alarm signal") threading.Timer(self.__interval * 60, self.time_handler) if self.__count == 0: self.__logger.debug("Dumping registered accounts Database") self.__storage.sync() self.__count = 60 / self.__interval else: self.__count -= 1 """ Component authentication handler """ def authenticated(self): self.__logger.debug("AUTHENTICATED") Component.authenticated(self) for jid, name in self.__storage.keys(): p = Presence(from_jid = name + "@" + unicode(self.jid), \ to_jid = jid, stanza_type = "probe") self.stream.send(p) for jid in self.__storage.keys(()): p = Presence(from_jid = unicode(self.jid), \ to_jid = jid, stanza_type = "probe") self.stream.send(p) self.stream.set_iq_get_handler("query", "jabber:iq:version", \ self.get_version) self.stream.set_iq_get_handler("query", "jabber:iq:register", \ self.get_register) self.stream.set_iq_set_handler("query", "jabber:iq:register", \ self.set_register) self.stream.set_presence_handler("available", \ self.presence_available) self.stream.set_presence_handler("probe", \ self.presence_available) self.stream.set_presence_handler("unavailable", \ self.presence_unavailable) self.stream.set_presence_handler("unsubscribe", \ self.presence_unsubscribe) self.stream.set_presence_handler("unsubscribed", \ self.presence_unsubscribed) self.stream.set_presence_handler("subscribe", \ self.presence_subscribe) self.stream.set_presence_handler("subscribed", \ self.presence_subscribed) self.stream.set_message_handler("normal", \ self.message) def stream_state_changed(self,state,arg): self.__logger.debug("*** State changed: %s %r ***" % (state,arg)) """ Discovery get info handler """ def disco_get_info(self, node, iq): self.__logger.debug("DISCO_GET_INFO") di = DiscoInfo() if node is None: di.add_feature("jabber:iq:version") di.add_feature("jabber:iq:register") DiscoIdentity(di, "Jabber Mail Component", "headline", "mail") else: di.add_feature("jabber:iq:register") return di """ Discovery get nested nodes handler """ def disco_get_items(self, node, iq): self.__logger.debug("DISCO_GET_ITEMS") base_from_jid = unicode(iq.get_from().bare()) di = DiscoItems() if not node: for jid, name in self.__storage.keys(): account = self.__storage[(jid, name)] str_name = account.get_type() + " connection " + name if account.get_type()[0:4] == "imap": str_name += " (" + account.mailbox + ")" DiscoItem(di, JID(name + "@" + unicode(self.jid)), \ name, str_name) return di """ Get Version handler """ def get_version(self, iq): self.__logger.debug("GET_VERSION") iq = iq.make_result_response() q = iq.new_query("jabber:iq:version") q.newTextChild(q.ns(), "name", "Jabber Mail Component") q.newTextChild(q.ns(), "version", "0.1") self.stream.send(iq) return 1 """ Send back register form to user """ def get_register(self, iq): self.__logger.debug("GET_REGISTER") base_from_jid = unicode(iq.get_from().bare()) to = iq.get_to() iq = iq.make_result_response() q = iq.new_query("jabber:iq:register") if to and to != self.jid: self.get_reg_form_init(base_from_jid, to.node).attach_xml(q) else: self.get_reg_form().attach_xml(q) self.stream.send(iq) return 1 """ Handle user registration response """ def set_register(self, iq): self.__logger.debug("SET_REGISTER") to = iq.get_to() from_jid = iq.get_from() base_from_jid = unicode(from_jid.bare()) remove = iq.xpath_eval("r:query/r:remove", \ {"r" : "jabber:iq:register"}) if remove: for jid, name in self.__storage.keys(): p = Presence(from_jid = name + "@" + unicode(self.jid), \ to_jid = from_jid, \ stanza_type = "unsubscribe") self.stream.send(p) p = Presence(from_jid = name + "@" + unicode(self.jid), \ to_jid = from_jid, \ stanza_type = "unsubscribed") self.stream.send(p) del self.__storage[(jid, name)] p = Presence(from_jid = self.jid, to_jid = from_jid, \ stanza_type = "unsubscribe") self.stream.send(p) p = Presence(from_jid = self.jid, to_jid = from_jid, \ stanza_type = "unsubscribed") self.stream.send(p) return 1 query = iq.get_query() x = X() x.from_xml(query.children) if x.fields.has_key("name"): name = x.fields["name"].value.lower() else: name = u"" if x.fields.has_key("login"): login = x.fields["login"].value else: login = u"" if x.fields.has_key("password"): password = x.fields["password"].value else: password = u"" if x.fields.has_key("host"): host = x.fields["host"].value else: host = u"" if x.fields.has_key("mailbox"): mailbox = x.fields["mailbox"].value else: mailbox = u"" if x.fields.has_key("type"): type = x.fields["type"].value else: type = u"pop3" if x.fields.has_key("port") and x.fields["port"].value != "": port = int(x.fields["port"].value) else: port = None if x.fields.has_key("chat_action") and x.fields["chat_action"].value != "": chat_action = int(x.fields["chat_action"].value) else: chat_action = mailconnection.DO_NOTHING if x.fields.has_key("online_action") and x.fields["online_action"].value != "": online_action = int(x.fields["online_action"].value) else: online_action = mailconnection.DO_NOTHING if x.fields.has_key("away_action") and x.fields["away_action"].value != "": away_action = int(x.fields["away_action"].value) else: away_action = mailconnection.DO_NOTHING if x.fields.has_key("xa_action") and x.fields["xa_action"].value != "": xa_action = int(x.fields["xa_action"].value) else: xa_action = mailconnection.DO_NOTHING if x.fields.has_key("dnd_action") and x.fields["dnd_action"].value != "": dnd_action = int(x.fields["dnd_action"].value) else: dnd_action = mailconnection.DO_NOTHING if x.fields.has_key("offline_action") and x.fields["offline_action"].value != "": offline_action = int(x.fields["offline_action"].value) else: offline_action = mailconnection.DO_NOTHING if x.fields.has_key("interval") and x.fields["interval"].value != "": interval = int(x.fields["interval"].value) else: interval = None self.__logger.debug(u"New Account: %s, %s, %s, %s, %s, %s, %s %i %i %i %i %i %i %i" \ % (name, login, password, host, str(port), \ mailbox, type, chat_action, online_action, away_action, \ xa_action, dnd_action, offline_action, interval)) iq = iq.make_result_response() self.stream.send(iq) if not self.__storage.has_key((base_from_jid,)): p = Presence(from_jid = self.jid, to_jid = base_from_jid, \ stanza_type="subscribe") self.stream.send(p) ## Update account if port != None: socket = host + ":" + str(port) else: socket = host if self.__storage.has_key((base_from_jid, name)): m = Message(from_jid = self.jid, to_jid = from_jid, \ stanza_type = "message", \ body = u"Updated %s connection '%s': Registered with "\ "username '%s' and password '%s' on '%s'" \ % (type, name, login, password, socket)) self.stream.send(m) else: m = Message(from_jid = self.jid, to_jid = from_jid, \ stanza_type = "message", \ body = u"New %s connection '%s': Registered with " \ "username '%s' and password '%s' on '%s'" \ % (type, name, login, password, socket)) self.stream.send(m) p = Presence(from_jid = name + "@" + unicode(self.jid), \ to_jid = base_from_jid, \ stanza_type="subscribe") self.stream.send(p) self.__storage[(base_from_jid, name)] = account = \ mailconnection_factory.get_new_mail_connection(type) account.login = login account.password = password account.host = host account.chat_action = chat_action account.online_action = online_action account.away_action = away_action account.xa_action = xa_action account.dnd_action = dnd_action account.offline_action = offline_action account.interval = interval if port: account.port = port if type[0:4] == "imap": account.mailbox = mailbox return 1 """ Handle presence availability """ def presence_available(self, stanza): self.__logger.debug("PRESENCE_AVAILABLE") from_jid = stanza.get_from() base_from_jid = unicode(from_jid.bare()) name = stanza.get_to().node show = stanza.get_show() self.__logger.debug("SHOW : " + str(show)) if name: self.__logger.debug("TO : " + name + " " + base_from_jid) if not name and self.__storage.has_key((base_from_jid,)): p = Presence(from_jid = self.jid, \ to_jid = from_jid, \ status = \ str(len(self.__storage.keys((base_from_jid,)))) \ + " accounts registered.", \ show = show, \ stanza_type = "available") self.stream.send(p) elif self.__storage.has_key((base_from_jid, name)): account = self.__storage[(base_from_jid, name)] # Make available to receive mail only when online account.status = "online" # TODO get real status = (not show) p = Presence(from_jid = name + "@" + \ unicode(self.jid), \ to_jid = from_jid, \ status = account.get_status_msg(), \ show = show, \ stanza_type = "available") self.stream.send(p) return 1 """ handle presence unavailability """ def presence_unavailable(self, stanza): self.__logger.debug("PRESENCE_UNAVAILABLE") from_jid = stanza.get_from() base_from_jid = unicode(from_jid.bare()) if stanza.get_to() == unicode(self.jid): for jid, name in self.__storage.keys(): self.__storage[(base_from_jid, name)].status = "offline" # TODO get real status p = Presence(from_jid = name + "@" + unicode(self.jid), \ to_jid = from_jid, \ stanza_type = "unavailable") self.stream.send(p) p = Presence(from_jid = stanza.get_to(), to_jid = from_jid, \ stanza_type = "unavailable") self.stream.send(p) return 1 """ handle subscribe presence from user """ def presence_subscribe(self, stanza): self.__logger.debug("PRESENCE_SUBSCRIBE") p = stanza.make_accept_response() self.stream.send(p) return 1 """ handle subscribed presence from user """ def presence_subscribed(self, stanza): self.__logger.debug("PRESENCE_SUBSCRIBED") name = stanza.get_to().node from_jid = stanza.get_from() base_from_jid = unicode(from_jid.bare()) if name is not None and self.__storage.has_key((base_from_jid, name)): account = self.__storage[(base_from_jid, name)] account.status = "online" # TODO retrieve real status p = Presence(from_jid = stanza.get_to(), to_jid = from_jid, \ status = account.get_status_msg(), \ stanza_type = "available") self.stream.send(p) return 1 """ handle unsubscribe presence from user """ def presence_unsubscribe(self, stanza): self.__logger.debug("PRESENCE_UNSUBSCRIBE") name = stanza.get_to().node from_jid = stanza.get_from() base_from_jid = unicode(from_jid.bare()) if name is not None and self.__storage.has_key((base_from_jid, name)): del self.__storage[(base_from_jid, name)] p = Presence(from_jid = stanza.get_to(), to_jid = from_jid, \ stanza_type = "unsubscribe") self.stream.send(p) p = stanza.make_accept_response() self.stream.send(p) return 1 """ handle unsubscribed presence from user """ def presence_unsubscribed(self, stanza): self.__logger.debug("PRESENCE_UNSUBSCRIBED") p = Presence(from_jid = stanza.get_to(), to_jid = stanza.get_from(), \ stanza_type = "unavailable") self.stream.send(p) self.__storage.sync() return 1 """ Handle new message """ def message(self, message): self.__logger.debug("MESSAGE: " + message.get_body()) name = message.get_to().node base_from_jid = unicode(message.get_from().bare()) # if name and self.__registered.has_key(base_from_jid): # body = message.get_body() # cmd = body.split(' ') # if cmd[0] == "check": # self.check_mail(base_from_jid, name) # elif cmd[0] == "dump": # body = "" # for jid in self.__registered.keys(): # for name in self.__registered[jid].keys(): # body += name + " for user " + jid # msg = Message(from_jid = self.jid, to_jid = base_from_jid, \ # stanza_type = "message", \ # body = body) # self.stream.send(msg) return 1 """ Check mail account """ def check_mail(self, jid, name): self.__logger.debug("CHECK_MAIL") account = self.__storage[(jid, name)] action = account.action if action != "nothing": try: self.__logger.debug("Checking " \ + name) self.__logger.debug("\t" + account.login \ + "@" + account.host) account.connect() mail_list = account.get_mail_list() if not mail_list or mail_list[0] == '': num = 0 else: num = len(mail_list) # unseen mails checked by external client if num < account.lastcheck: account.lastcheck = 0 if action == "retrieve": while account.lastcheck < num: body = account.get_mail(int(mail_list[account.lastcheck])) mesg = Message(from_jid = name + "@" + \ unicode(self.jid), \ to_jid = jid, \ stanza_type = "message", \ body = body) self.stream.send(mesg) account.lastcheck += 1 else: body = "" while account.lastcheck < num: body += \ account.get_mail_summary(int(mail_list[account.lastcheck])) \ + "\n----------------------------------\n" account.lastcheck += 1 if body != "": mesg = Message(from_jid = name + "@" + \ unicode(self.jid), \ to_jid = jid, \ stanza_type = "headline", \ body = body) self.stream.send(mesg) account.disconnect() except Exception,e: self.__logger.debug("Error while checking mail : %s" \ % (e)) """ check mail handler """ def check_all_mail(self): self.__logger.debug("CHECK_ALL_MAIL") ## TODO # for jid in self.__registered.keys(): # for name in self.__registered[jid].keys(): # self.check_mail(jid, name)