# -*- coding: utf-8 -*- # Copyright (C) 2008-2010 Warp Networks, S.L. # Author: Pablo Martí # # 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., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. """Message Assembly Layer for Wader""" from time import mktime from twisted.internet import reactor from twisted.internet.defer import succeed, gatherResults, Deferred from twisted.python import log from messaging.sms import SmsDeliver from messaging.sms.wap import (extract_push_notification, is_a_wap_push_notification, is_mms_notification) from wader.common.aterrors import (CMSError314, SimBusy, SimNotStarted, SimFailure) from wader.common.encoding import pack_dbus_safe_string from wader.common.signals import SIG_MMS, SIG_SMS, SIG_SMS_COMP, SIG_SMS_DELV from wader.common.sms import Message from core.mms import dbus_data_to_mms STO_INBOX, STO_DRAFTS, STO_SENT = 1, 2, 3 # XXX: What should this threshold be? SMS_DATE_THRESHOLD = 5 MAL_RETRIES = 3 MAL_RETRY_TIMEOUT = 3 def debug(s): # Change this to remove debugging if 1: print s def should_fragment_be_assembled(sms, fragment): """Returns True if ``fragment`` can be assembled to ``sms``""" if sms.completed: # SMS is completed, no way to assemble it return False if sms.ref != fragment.ref: # different sms id return False if sms.datetime is not None and fragment.datetime is not None: # if datetime is present convert it to unix time time1 = mktime(sms.datetime.timetuple()) time2 = mktime(fragment.datetime.timetuple()) if abs(time1 - time2) > SMS_DATE_THRESHOLD: return False if sms.cnt != fragment.cnt: # number of parts return False if sms.number != fragment.number: # different sender return False if sms.csca != fragment.csca: # different SMSC return False debug("MAL: Assembling fragment %s with sms %s" % (fragment, sms)) return True class CacheIncoherenceError(Exception): """Raised upon a cache incoherence error""" class NotificationContainer(object): """ I am a WAP push notification container I keep a list with all the wap_push notifications and provide some operations on it """ def __init__(self, tx_id=None): self.notifications = [] self.tx_id = tx_id def add_notification(self, wap_push, notification): self.notifications.append((wap_push, notification)) def get_last_notification(self): """Returns the last received notification""" # comp function must return an int ret = sorted(self.notifications, lambda _, n: int(mktime(n[0].datetime.timetuple()))) # return the last element return ret[-1][1] class MessageAssemblyLayer(object): """I am a transparent layer to perform operations on concatenated SMS""" def __init__(self, wrappee): self.wrappee = wrappee self.last_sms_index = 0 self.last_wap_index = 0 self.sms_map = {} self.wap_map = {} self.sms_pending = [] self.cached = False def initialize(self, obj=None): debug("MAL::initialize obj: %s" % obj) if obj is not None: self.wrappee = obj # revert to initial state self.last_sms_index = self.last_wap_index = 0 self.sms_map = {} self.sms_pending = [] self.cached = False # populate sms cache return self._do_initialize() def _do_initialize(self): # init counter self.wrappee.state_dict['mal_init_retries'] = 0 deferred = Deferred() def list_sms(auxdef): def sim_busy_eb(failure): failure.trap(SimBusy, SimNotStarted, CMSError314) self.wrappee.state_dict['mal_init_retries'] += 1 if self.wrappee.state_dict['mal_init_retries'] > MAL_RETRIES: raise SimFailure("Could not initialize MAL") reactor.callLater(MAL_RETRY_TIMEOUT, list_sms, auxdef) d = self.list_sms() d.addErrback(sim_busy_eb) d.chainDeferred(auxdef) return auxdef return list_sms(deferred) def _do_add_sms(self, sms, indexes=None): """ Adds ``sms`` to the cache using ``indexes`` if defined It returns the logical index where it was stored """ #debug("MAL::_do_add_sms sms: %s indexes: %s" % (sms, indexes)) # save the real index if indexes is None if indexes: map(sms.real_indexes.add, indexes) else: sms.real_indexes.add(sms.index) #debug("MAL::_do_add_sms sms.real_indexes %s" % sms.real_indexes) # assign a new logical index self.last_sms_index += 1 sms.index = self.last_sms_index # reference the sms by this logical index self.sms_map[self.last_sms_index] = sms return self.last_sms_index def _add_sms(self, sms, emit=False): """ Adds ``sms`` to the cache It returns the logical index where it was stored """ debug("MAL::_add_sms: %s" % sms) if not sms.cnt: index = self._do_add_sms(sms) debug("MAL::_add_sms single part SMS added with " "logical index: %d" % index) # being a single part sms, completed == True if emit: for signal in [SIG_SMS, SIG_SMS_COMP]: self.wrappee.emit_signal(signal, index, True) return index else: for index, value in self.sms_map.iteritems(): if should_fragment_be_assembled(value, sms): # append the sms and emit the different signals completed = self.sms_map[index].append_sms(sms) debug("MAL::_add_sms multi part SMS with logical " "index %d, completed %s" % (index, completed)) # check if we have just assembled a WAP push notification if completed: notification = self.sms_map[index] if self._is_a_wap_push_notification(notification): if self._process_wap_push_notification(index, emit): debug("MAL::_add_sms MMS processed OK") # There's no need to return an index here as we # have been called by gen_cache and MMS has a # different index scheme than SMS. return # XXX: Must have been a non-MMS notification WAP # push, there's nothing we can do with those # presently. Leave them to be displayed as # SMS, although poorly, so that they may be # removed by the user if desired. if emit: # only emit signals in runtime, not startup self.wrappee.emit_signal(SIG_SMS, index, completed) if completed: self.wrappee.emit_signal(SIG_SMS_COMP, index, completed) # return sms logical index return index # this is the first fragment of this multipart sms, add it # to cache, emit signal and wait for the rest of fragments # to arrive. It returns the logical index where was stored index = self._do_add_sms(sms) if emit: self.wrappee.emit_signal(SIG_SMS, index, False) debug("MAL::_add_sms first part of a multi part SMS added with " "logical index %d" % index) return index def _after_ack_delete_notifications(self, _, index): try: container = self.wap_map.pop(index) except KeyError: debug("MessageAssemblyLayer::_after_ack_delete_notifications" " NotificationContainer %d does not exist" % index) return indexes = [] for wap_push, _ in container.notifications: indexes.extend(wap_push.real_indexes) ret = map(self.wrappee.do_delete_sms, indexes) return gatherResults(ret) def acknowledge_mms(self, index, extra_info): d = self.wrappee.do_acknowledge_mms(index, extra_info) d.addCallback(self._after_ack_delete_notifications, index) return d def delete_sms(self, index): """Deletes sms identified by ``index``""" debug("MAL::delete_sms: %d" % index) if index in self.sms_map: sms = self.sms_map.pop(index) ret = map(self.wrappee.do_delete_sms, sms.real_indexes) debug("MAL::delete_sms deleting %s" % sms.real_indexes) return gatherResults(ret) error = "SMS with logical index %d does not exist" raise CacheIncoherenceError(error % index) def download_mms(self, index, extra_info): container = self.wap_map[index] d = self.wrappee.do_download_mms(container.get_last_notification(), extra_info) return d def get_sms(self, index): """Returns the sms identified by ``index``""" if index in self.sms_map: return succeed(self.sms_map[index]) error = "SMS with logical index %d does not exist" raise CacheIncoherenceError(error % index) def list_available_mms_notifications(self): """Returns all the lingering sms wap push notifications""" ret = [] for index, container in self.wap_map.items(): notification = container.get_last_notification() ret.append((index, self._clean_headers(notification))) return succeed(ret) def _list_sms(self): ret = [] for sms in self.sms_map.values(): if sms.fmt != 0x04: ret.append(sms.to_dict()) else: # WAP Pushes are binary and may not be valid DBus strings _sms = sms.to_dict() _sms['text'] = pack_dbus_safe_string(_sms['text']) ret.append(_sms) return ret def list_sms(self): """Returns all the sms""" debug("MAL::list_sms") def gen_cache(messages): debug("MAL::list_sms::gen_cache") self.sms_map = {} for sms in messages: self._add_sms(sms) self.cached = True return self._list_sms() if self.cached: debug("MAL::list_sms::cached path") return succeed(self._list_sms()) d = self.wrappee.do_list_sms() d.addCallback(gen_cache) return d def list_sms_raw(self): """Returns all the raw sms, not assembled via the mal""" debug("MAL::list_sms_raw") return self.wrappee.do_list_sms() def send_mms(self, mms, extra_info): debug("MAL::send_mms: %s" % mms) d = self.wrappee.do_send_mms(dbus_data_to_mms(mms), extra_info) return d def send_sms(self, sms): debug("MAL::send_sms: %s" % sms) if not sms.status_request: return self.wrappee.do_send_sms(sms) d = self.wrappee.do_send_sms(sms) d.addCallback(self._save_sms_reference, sms) return d def send_sms_from_storage(self, index): debug("MAL::send_sms_from_storage: %d" % index) if index in self.sms_map: sms = self.sms_map.pop(index) indexes = sorted(sms.real_indexes) debug("MAL::send_sms_from_storage sending %s" % indexes) ret = map(self.wrappee.do_send_sms_from_storage, indexes) return gatherResults(ret) error = "SMS with logical index %d does not exist" raise CacheIncoherenceError(error % index) def save_sms(self, sms): """Saves ``sms`` in the cache memorizing the resulting indexes""" debug("MAL::save_sms: %s" % sms) d = self.wrappee.do_save_sms(sms) d.addCallback(lambda indexes: self._do_add_sms(sms, indexes)) d.addCallback(lambda logical_index: [logical_index]) return d def _save_sms_reference(self, indexes, sms): sms.status_references.extend(indexes) sms.status_reference = indexes[0] self.sms_pending.append(sms) return [sms.status_reference] def on_sms_delivery_report(self, pdu): """Executed when a SMS delivery report is received""" data = SmsDeliver(pdu).data sms = Message.from_dict(data) assert sms.is_status_report(), "SMS IS NOT STATUS REPORT" # XXX: O(N) here for _sms in self.sms_pending: if sms.ref in _sms.status_references: # one confirmation received _sms.status_references.remove(sms.ref) # no more status references? Then we are done, remove it from # the status_references list and emit signal if not _sms.status_references: self.sms_pending.remove(_sms) return self.wrappee.emit_signal(SIG_SMS_DELV, _sms.status_reference) break else: log.err("Received status report with " "unknown reference: %d" % sms.ref) def on_sms_notification(self, index): """Executed when a SMS notification is received""" debug("MAL::on_sms_notification: %d" % index) d = self.wrappee.do_get_sms(index) d.addCallback(self._add_sms, emit=True) return d def _is_a_wap_push_notification(self, sms): """Returns True if ``sms`` is a WAP push notification""" if sms.fmt != 0x04: return False return is_a_wap_push_notification(sms.text) def _process_wap_push_notification(self, index, emit): """ Processes WAP push notification identified by ``index`` If ``emit`` is True, it will emit a MMSReceived signal if this the first time we see this notification. """ notification = extract_push_notification(self.sms_map[index].text) if not is_mms_notification(notification): debug("MAL::_process_wap_push_notification: is not for MMS") return False wap_push = self.sms_map.pop(index) index = None new = False _from = notification.headers['From'] tx_id = notification.headers['Transaction-Id'] for i, container in self.wap_map.items(): if container.tx_id != tx_id: continue noti = container.get_last_notification() if _from == noti.headers['From']: index = i break else: # this is the first time we see this tx_id index = self.last_wap_index self.last_wap_index += 1 new = True container = self.wap_map.get(index, NotificationContainer(tx_id)) container.add_notification(wap_push, notification) self.wap_map[index] = container if emit and new: # emit the signal if this is the first time we # see this notification notification = container.get_last_notification() headers = self._clean_headers(notification) self.wrappee.emit_signal(SIG_MMS, index, headers) return True def _clean_headers(self, notification): """Clean ``headers`` so its safe to send the dict via DBus""" hdrs = notification.headers.copy() hdrs['Content-Type'] = notification.content_type return hdrs