Imported Upstream version 1.29.90

10 files changed, 2242 insertions, 5 deletions

diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index f46bf16..84a0db0 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -5,6 +5,7 @@
 project (Gammu-contrib C)
 
 option(INSTALL_GNAPPLET "Install Gnapplet binaries" ON)
+option(INSTALL_S60 "Install Series 60 applet binaries" ON)
 option(INSTALL_MEDIA "Install sample media files" ON)
 option(INSTALL_PHP_EXAMPLES "Install PHP example scripts" ON)
 
@@ -17,12 +18,15 @@ endif (BASH_BIN)
 option(INSTALL_LSB_INIT "Install LSB compatible init script for Gammu" OFF)
 option(INSTALL_UDEV_RULES "Install udev rules for Gammu" OFF)
 
-set (SYMBIAN_FILES
-    symbian/readme.txt
+set (GNAPPLET_FILES
     symbian/gnapplet.ini
     symbian/gnapplet.sis
     )
 
+set (S60_FILES
+    s60/series60-remote.sis
+    )
+
 file(GLOB MEDIA_FILES "media/*.txt" "media/*.nlm")
 
 set (PHP_EXAMPLES
@@ -44,12 +48,20 @@ set (PHP_EXAMPLES
 
 if (INSTALL_GNAPPLET)
     install (
-        FILES ${SYMBIAN_FILES}
-        DESTINATION "${INSTALL_DOC_DIR}/symbian"
-        COMPONENT "gnapplet"
+        FILES ${GNAPPLET_FILES}
+        DESTINATION "${INSTALL_DATA_DIR}"
+        COMPONENT "symbian"
         )
 endif (INSTALL_GNAPPLET)
 
+if (INSTALL_S60)
+    install (
+        FILES ${S60_FILES}
+        DESTINATION "${INSTALL_DATA_DIR}"
+        COMPONENT "symbian"
+        )
+endif (INSTALL_S60)
+
 if (INSTALL_MEDIA)
     install (
         FILES ${MEDIA_FILES}
diff --git a/contrib/s60/create_package b/contrib/s60/create_package
new file mode 100755
index 0000000..829f86a
--- /dev/null
+++ b/contrib/s60/create_package
@@ -0,0 +1,43 @@
+#!/bin/sh
+# Create series60-remote.sis
+
+PYS60DIR=~/PythonForS60
+VERSION=0.4.80
+CURDIR=$PWD
+
+
+mkdir tmp
+
+cp *.py tmp/
+
+cd $PYS60DIR
+
+python2.5 $PYS60DIR/ensymble.py py2sis \
+    --appname="Series60 - Remote" \
+    --version=$VERSION \
+    --lang=EN \
+    --shortcaption="S60-Remote" \
+    --caption="Series60 - Remote" \
+    --vendor="Gammu team" \
+    --caps=LocalServices+ReadUserData+WriteUserData+WriteUserData+NetworkServices+UserEnvironment \
+    --icon="$CURDIR/icon.svg" \
+    --verbose \
+    $CURDIR/tmp \
+    $CURDIR/series60-remote.sis
+
+python2.5 $PYS60DIR/ensymble.py py2sis \
+    --appname="Series60 - Remote" \
+    --version=$VERSION \
+    --lang=EN \
+    --shortcaption="S60-Remote" \
+    --caption="Series60 - Remote" \
+    --vendor="Gammu team" \
+    --caps=LocalServices+Location+ReadDeviceData+ReadUserData+WriteUserData+WriteUserData+NetworkServices+UserEnvironment \
+    --icon="$CURDIR/icon.svg" \
+    --verbose \
+    $CURDIR/tmp \
+    $CURDIR/series60-remote-sign.sis
+
+cd $CURDIR
+
+rm -rf tmp
diff --git a/contrib/s60/default.py b/contrib/s60/default.py
new file mode 100644
index 0000000..0d24349
--- /dev/null
+++ b/contrib/s60/default.py
@@ -0,0 +1,1208 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2008 - 2010 Lukas Hetzenecker <LuHe@gmx.at>
+
+import sys
+sys.path.append('e:\python\libs')
+sys.path.append('c:\python\libs')
+
+import os.path
+
+import time
+import math
+import md5
+
+import sysinfo
+import e32
+import inbox
+import contacts
+import telephone
+import messaging
+import location
+import graphics
+from appuifw import *
+from status_numbers import *
+
+if float(e32.pys60_version[:3]) >= 1.9:
+    import e32calendar as calendar
+else:
+    import calendar
+
+if float(e32.pys60_version[:3]) >= 1.9:
+    import btsocket as socket
+else:
+    import socket
+import socket as pysocket
+
+import cPickle
+
+
+VERSION = 0.5
+PORT = 18
+
+# For hash functions
+CONTACT_SEP = chr(0x1F) # Unit Separator
+ENTRY_SEP = chr(0x1F) # Unit Separator
+FIELD_SEP = chr(0x1E) # Record Separator
+INFO_SEP = chr(0x1D) # Group Separator
+
+class Mobile(object):
+    def __init__(self):
+        self.connected = False
+        self.service = False
+        self.useCanvas = True
+        self.client = None
+        self.port = PORT
+
+        self.loadConfig()
+
+        self.inbox = inbox.Inbox(inbox.EInbox)
+        self.sent = inbox.Inbox(inbox.ESent)
+        self.contactDb = contacts.open()
+        self.calendarDb = calendar.open()
+        self.currentMessage = None
+        self.__partialMessage = ""
+
+        self.inbox.bind(self.newMessage)
+        #telephone.call_state(self.handleCall)
+
+        self.initUi()
+        self.startService()
+
+    def getCurrentDir(self):
+        try:
+            return self._current_dir
+        except:
+            pass
+
+        try:
+            raise Exception
+        except Exception:
+            frame = sys.exc_info()[2].tb_frame
+            path = frame.f_code.co_filename
+            dirpath = os.path.split(path)[0]
+            self._current_dir = os.path.realpath(dirpath)
+
+        return self._current_dir
+
+    def getFilename(self, name):
+        return os.path.join(self.getCurrentDir(), name)
+
+    def getConfigFilename(self):
+        return self.getFilename('s60.cfg')
+
+    def getScreenshotFilename(self):
+        return self.getFilename('screenshot.png')
+
+    def loadConfig(self):
+        try:
+            f = file(self.getConfigFilename(), 'rb')
+            conf = cPickle.load(f)
+            f.close()
+            if 'port' in conf:
+                self.port = conf['port']
+            if 'useCanvas' in conf:
+                self.useCanvas = conf['useCanvas']
+        except IOError, r:
+            pass
+
+    def saveConfig(self):
+        try:
+            f = file(self.getConfigFilename(), 'wb')
+            conf = {
+                'port': self.port,
+                'useCanvas': self.useCanvas,
+                }
+            cPickle.dump(conf, f)
+            f.close()
+        except IOError, r:
+            pass
+
+    def initUi(self):
+        app.title = u"Series 60 - Remote"
+
+        if self.useCanvas:
+            self.canvas = Canvas(redraw_callback=self.statusUpdate)
+            app.body = self.canvas
+
+        self.lock = e32.Ao_lock()
+        app.exit_key_handler = self.exitHandler
+        app.screen = 'normal'
+        app.menu = [
+            (u'About', self.aboutHandler),
+            (u'Change port', self.portHandler),
+            (u'Toggle Bluetooth', self.toggleHandler),
+            (u'Exit', self.exitHandler),
+            ]
+
+    def statusUpdate(self, rect=None):
+        if not self.useCanvas:
+            return
+
+        self.canvas.clear((255,255,255))
+        if self.service:
+            self.canvas.text((1,14),u"Service started at port %s" % self.port,0xff0000)
+        else:
+            self.canvas.text((1,14),u"Service stopped",0xff0000)
+
+        if self.connected:
+            self.canvas.text((1,34), u"Connected to: " + self.client[1], 0x0000ff)
+        else:
+            self.canvas.text((1,34), u"No active connection", 0x0000ff)
+
+    def startService(self):
+        self.service = True
+        self.statusUpdate()
+
+        self.sock = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
+        self.sock.bind(('', self.port))
+        self.sock.listen(1)
+
+        socket.set_security(self.sock,  socket.AUTH | socket.AUTHOR)
+        socket.bt_advertise_service(u"pys60_remote", self.sock, True, socket.RFCOMM)
+        note(u'Listenning on port %d' % self.port)
+
+        self.listen()
+
+    def stopService(self):
+        if (self.service):
+            self.service = False
+            self.statusUpdate()
+
+            socket.bt_advertise_service(u"pys60_remote", self.sock, False, socket.RFCOMM)
+            self.sock.close()
+            self.sock = None
+
+    def disconnect(self):
+        if(self.connected):
+            self.connected = False
+
+            try:
+                self.fos.close()
+            except socket.error:
+                pass
+            except pysocket.error:
+                pass
+
+            try:
+                self.fis.close()
+            except socket.error:
+                pass
+            except pysocket.error:
+                pass
+
+            try:
+                self.client[0].close()
+            except socket.error:
+                pass
+            except pysocket.error:
+                pass
+            self.client = None
+
+            self.statusUpdate()
+
+    def listen(self):
+        while self.service:
+            self.client = self.sock.accept()
+
+            self.connected = True
+            self.statusUpdate()
+            address = str(self.client[1])
+            note(u'Connected client %s' % address)
+
+            self.fos = self.client[0].makefile("w")
+            self.fis = self.client[0].makefile("r")
+
+            try:
+                self.send(NUM_CONNECTED,  PROTOCOL_VERSION)
+                self.wait()
+            except socket.error:
+                pass
+            except pysocket.error:
+                pass
+
+            self.disconnect()
+            note(u'Disconnected client %s' % address)
+
+    def send(self, header,  *message):
+        new_message = ""
+
+        if len(message) == 1:
+            new_message = unicode(message[0])
+        else:
+            for part in message:
+                new_message += unicode(part) + str(NUM_SEPERATOR)
+
+        length = 1000
+        if len(new_message) > length:
+            parts = int(math.ceil(len(new_message) / float(length)))
+            sentParts = 0
+            for i in range(parts):
+                part = new_message[sentParts*length:sentParts*length+length]
+                if sentParts == parts-1:
+                    self.send(header,  part)
+                else:
+                    self.send(NUM_PARTIAL_MESSAGE,  part)
+                sentParts += 1
+            return
+
+        self.fos.write(unicode(str(header) + str(NUM_END_HEADER) + new_message + str(NUM_END_TEXT)).encode("utf8") )
+        self.fos.flush()
+
+    def wait(self):
+        while(True):
+            data = self.fis.readline()
+
+            header = int(data.split(NUM_END_HEADER)[0])
+            message = unicode(data.split(NUM_END_HEADER)[1],  "utf8")
+
+            if (header != NUM_PARTIAL_MESSAGE and self.__partialMessage):
+                message = self.__partialMessage + message
+                self.__partialMessage = ""
+
+            if (header == NUM_PARTIAL_MESSAGE):
+                self.__partialMessage += message
+
+            elif (header == NUM_HELLO_REQUEST):
+                    self.send(NUM_HELLO_REPLY)
+
+            elif (header == NUM_SYSINFO_REQUEST):
+                full = bool(int(message.split(NUM_SEPERATOR)[0]))
+                self.sendSysinfo(full)
+
+            elif (header == NUM_LOCATION_REQUEST):
+                self.sendLocation()
+
+            elif (header == NUM_DIAL):
+                try:
+                    telephone.dial(message.split(NUM_SEPERATOR)[0])
+                except:
+                    pass
+
+            elif (header == NUM_HANGUP):
+                try:
+                    telephone.hang_up()
+                except:
+                    pass
+
+            elif (header == NUM_CONTACTS_REQUEST_HASH_ALL):
+                self.sendContactHash()
+
+            elif (header == NUM_CONTACTS_REQUEST_HASH_SINGLE):
+                self.sendContactHashSingle()
+
+            elif (header == NUM_CONTACTS_REQUEST_COUNT):
+                self.send(NUM_CONTACTS_REPLY_COUNT, len(self.contactDb))
+
+            elif (header == NUM_CONTACTS_REQUEST_CONTACT):
+                key = int(message.split(NUM_SEPERATOR)[0])
+                try:
+                    contact = self.contactDb[key]
+                    self.sendContact(contact)
+                except:
+                    self.send(NUM_CONTACTS_REPLY_CONTACT_NOT_FOUND)
+
+            elif (header == NUM_CONTACTS_REQUEST_CONTACTS_ALL):
+                self.sendAllContacts()
+
+            elif (header == NUM_CONTACTS_ADD):
+                contact = self.contactDb.add_contact()
+                contact.commit()
+                self.send(NUM_CONTACTS_ADD_REPLY_ID,  contact.id)
+
+            elif (header == NUM_CONTACTS_DELETE):
+                id = int(message)
+                if id in self.contactDb.keys():
+                    del self.contactDb[id]
+
+            elif (header == NUM_CONTACTS_CHANGE_ADDFIELD):
+                id = int(message.split(NUM_SEPERATOR)[0])
+                type = unicode(message.split(NUM_SEPERATOR)[1])
+                location = unicode(message.split(NUM_SEPERATOR)[2])
+                value = unicode(message.split(NUM_SEPERATOR)[3])
+                self.modifyContact("add",  id,  type,  location,  value)
+
+            elif (header == NUM_CONTACTS_CHANGE_REMOVEFIELD):
+                id = int(message.split(NUM_SEPERATOR)[0])
+                type = unicode(message.split(NUM_SEPERATOR)[1])
+                location = unicode(message.split(NUM_SEPERATOR)[2])
+                value = unicode(message.split(NUM_SEPERATOR)[3])
+                self.modifyContact("remove",  id,  type,  location,  value)
+
+            elif (header == NUM_CALENDAR_REQUEST_COUNT):
+                self.sendCalendarCount()
+
+            elif (header == NUM_CALENDAR_REQUEST_HASH_ALL):
+                self.sendCalendarHash()
+
+            #elif (header == NUM_CALENDAR_REQUEST_HASH_SINGLE):
+            #    self.sendCalendarHashSingle()
+
+            elif (header == NUM_CALENDAR_REQUEST_ENTRY):
+                key = int(message.split(NUM_SEPERATOR)[0])
+                try:
+                    entry = self.calendarDb[key]
+                    self.sendCalendarEntry(entry)
+                except:
+                    self.send(NUM_CALENDAR_REPLY_ENTRY_NOT_FOUND)
+
+            elif (header == NUM_CALENDAR_REQUEST_ENTRIES_ALL):
+                self.sendAllCalendarEntries()
+
+            elif (header == NUM_CALENDAR_ENTRY_DELETE):
+                id = int(message)
+                try:
+                    del self.calendarDb[id]
+                except RuntimeError:
+                    # no such entry
+                    pass
+
+            elif (header == NUM_CALENDAR_ENTRY_CHANGE or header == NUM_CALENDAR_ENTRY_ADD):
+                ms = message.split(NUM_SEPERATOR)
+
+                if (header == NUM_CALENDAR_ENTRY_CHANGE):
+                    id = int(ms[0])
+                elif (header == NUM_CALENDAR_ENTRY_ADD):
+                    type = str(ms[0])
+
+                content = unicode(ms[1])
+                location = unicode(ms[2])
+                #start = float(ms[3]) if ms[3] else 0
+                if ms[3]:
+                    start = float(ms[3])
+                else:
+                    start = 0.0
+                #end = float(ms[4]) if ms[4] else None
+                if ms[4]:
+                    end = float(ms[4])
+                else:
+                    end = None
+                replication = str(ms[5])
+                #alarm = float(ms[6]) if ms[6] else None
+                if ms[6]:
+                    alarm = float(ms[6])
+                else:
+                    alarm = None
+                priority = int(ms[7])
+                repeat_type = str(ms[8])
+                repeat_days = str(ms[9])
+                repeat_exceptions = str(ms[10])
+                #repeat_start = float(ms[11]) if ms[11] else 0
+                if ms[11]:
+                    repeat_start = float(ms[11])
+                else:
+                    repeat_start = 0.0
+                #repeat_end = float(ms[12]) if ms[12] else None
+                if ms[12]:
+                    repeat_end = float(ms[12])
+                else:
+                    repeat_end = None
+                #repeat_interval = int(ms[13]) if ms[13] else 1
+                if ms[13]:
+                    repeat_interval = int(ms[13])
+                else:
+                    repeat_interval = 1
+
+                if (header == NUM_CALENDAR_ENTRY_CHANGE):
+                    self.modifyCalendarEntry(id,  content,  location,  start,  end,  replication,  alarm,  priority,  repeat_type,
+                                        repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval)
+                elif (header == NUM_CALENDAR_ENTRY_ADD):
+                    self.addCalendarEntry(type,  content,  location,  start,  end,  replication,  alarm,  priority,  repeat_type,
+                                        repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval)
+
+            elif (header == NUM_MESSAGE_REQUEST):
+                lastId = int(message.split(NUM_SEPERATOR)[0])
+                self.sendAllMessages(lastId)
+
+            elif (header == NUM_MESSAGE_REQUEST_ONE):
+                lastId = int(message.split(NUM_SEPERATOR)[0])
+                self.sendOneMessage(lastId)
+
+            elif (header == NUM_MESSAGE_REQUEST_UNREAD):
+                self.sendUnreadMessages()
+
+            elif (header == NUM_MESSAGE_REQUEST_LIST):
+                self.sendMessagesList()
+
+            elif (header == NUM_MESSAGE_REQUEST_COUNT):
+                self.sendMessagesCount()
+
+            elif (header == NUM_MESSAGE_SEND_REQUEST):
+                name = unicode(message.split(NUM_SEPERATOR)[0])
+                phone = unicode(message.split(NUM_SEPERATOR)[1])
+                enc = str(message.split(NUM_SEPERATOR)[2])
+                msg = unicode(message.split(NUM_SEPERATOR)[3])
+                self.sendMessage(name, phone, enc,  msg)
+
+            elif (header == NUM_SET_READ):
+                id = int(message.split(NUM_SEPERATOR)[0])
+                state = bool(message.split(NUM_SEPERATOR)[1])
+                self.setRead(id, state)
+
+            elif (header == NUM_MESSAGE_DELETE):
+                id = int(message.split(NUM_SEPERATOR)[0])
+                self.messageDelete(id)
+
+            elif (header == NUM_SCREENSHOT):
+                self.sendScreenshot()
+
+            elif (header == NUM_QUIT):
+                self.send(NUM_QUIT)
+                break
+
+    def sendSysinfo(self,  full):
+        self.send(NUM_SYSINFO_REPLY_START)
+        self.send(NUM_SYSINFO_REPLY_LINE, "program_version", VERSION)
+        self.send(NUM_SYSINFO_REPLY_LINE, "battery", sysinfo.battery())
+        self.send(NUM_SYSINFO_REPLY_LINE, "active_profile", sysinfo.active_profile())
+        self.send(NUM_SYSINFO_REPLY_LINE, "free_ram", sysinfo.free_ram())
+        self.send(NUM_SYSINFO_REPLY_LINE, "pys60_version", e32.pys60_version)
+
+        if sysinfo.active_profile() == u"offline":
+            # Return an error code if the phone is in offline mode
+            self.send(NUM_SYSINFO_REPLY_LINE, "signal_dbm", -1)
+            self.send(NUM_SYSINFO_REPLY_LINE, "signal_bars", -1)
+        else:
+            self.send(NUM_SYSINFO_REPLY_LINE, "signal_dbm", sysinfo.signal_dbm())
+            self.send(NUM_SYSINFO_REPLY_LINE, "signal_bars", sysinfo.signal_bars())
+
+        for drive,  free in sysinfo.free_drivespace().iteritems():
+            self.send(NUM_SYSINFO_REPLY_LINE, "free_drivespace", str(drive) + str(free))
+
+        if full:
+            self.send(NUM_SYSINFO_REPLY_LINE, "display", str(sysinfo.display_pixels()[0]) + "x" + str(sysinfo.display_pixels()[1]))
+            self.send(NUM_SYSINFO_REPLY_LINE, "imei", sysinfo.imei())
+            self.send(NUM_SYSINFO_REPLY_LINE, "model", sysinfo.sw_version())
+            self.send(NUM_SYSINFO_REPLY_LINE, "s60_version", e32.s60_version_info[0],  e32.s60_version_info[1] )
+            self.send(NUM_SYSINFO_REPLY_LINE, "total_ram", sysinfo.total_ram())
+            self.send(NUM_SYSINFO_REPLY_LINE, "total_rom", sysinfo.total_rom())
+
+        self.send(NUM_SYSINFO_REPLY_END)
+
+    def sendScreenshot(self):
+        fn = self.getScreenshotFilename()
+        shot = graphics.screenshot()
+        shot.save(fn)
+        note(u'Saved screenshot as %s' % fn)
+        f = file(fn, 'rb')
+        self.send(NUM_SCREENSHOT_REPLY, f.read().encode('base64'))
+        f.close()
+
+    def sendLocation(self):
+        loc = location.gsm_location()
+        if loc is None:
+            self.send(NUM_LOCATION_REPLY_NA)
+        else:
+            mcc, mnc, lac, cellid = loc
+            self.send(NUM_LOCATION_REPLY, '%03d' % mcc, '%02d' % mnc, '%X' % lac, '%X' % cellid)
+
+    def contactDict(self):
+        keys = self.contactDb.keys()
+
+        contactDict = dict()
+        for key in keys:
+            contact = self.contactDb[key]
+
+            # Check for empty title (please look in the comment for sendContact)
+            try:
+                contact.title
+            except TypeError:
+                continue
+
+            contactDict[contact.id] = list()
+            for field in contact:
+                _type = field.type
+                value = field.value
+                value = unicode(value)
+                value = value.replace(u'\u2029',  u'\n') # PARAGRAPH SEPARATOR (\u2029) replaced by LINE FEED (\u000a)
+                location = field.location
+
+                if _type == "unknown":
+                    continue
+                elif _type == "thumbnail_image":
+                    value = self.getContactThumbnail(contact)
+                    if not value:
+                        continue
+                elif _type == "date":
+                    value = self.getContactBirthday(contact)
+
+                if isinstance(value, type(None)):
+                   # Ignore this field
+                   continue
+
+                contactDict[contact.id].append((_type,  location,  value))
+            contactDict[contact.id].sort()
+
+        return contactDict
+
+    def sendContactHash(self):
+        contacts = self.contactDict()
+        keys = contacts.keys()
+        keys.sort()
+
+        hash = unicode()
+
+        for key in keys:
+            hash += str(key)
+            hash += FIELD_SEP
+            for _type,  location, value in contacts[key]:
+                hash += _type + INFO_SEP + location + INFO_SEP + value
+                hash += FIELD_SEP
+            hash += CONTACT_SEP
+
+        hash = hash.encode("utf8")
+        hash = md5.md5(hash).hexdigest()
+        self.send(NUM_CONTACTS_REPLY_HASH_ALL, hash)
+
+    def sendContactHashSingle(self):
+        self.send(NUM_CONTACTS_REPLY_HASH_SINGLE_START)
+
+        contacts = self.contactDict()
+        keys = contacts.keys()
+        keys.sort()
+
+        for key in keys:
+            hash = unicode()
+            for _type,  location, value in contacts[key]:
+                hash += _type + INFO_SEP + location + INFO_SEP + value
+                hash += FIELD_SEP
+
+            hash = hash.encode("utf8")
+            hash = md5.md5(hash).hexdigest()
+            self.send(NUM_CONTACTS_REPLY_HASH_SINGLE_LINE, key,  hash)
+
+        self.send(NUM_CONTACTS_REPLY_HASH_SINGLE_END)
+
+    def sendAllContacts(self):
+        keys = self.contactDb.keys()
+
+        for key in keys:
+            contact = self.contactDb[key]
+            self.sendContact(contact)
+        self.send(NUM_CONTACTS_REPLY_CONTACTS_ALL_END)
+
+    def sendContact(self,  contact):
+        # There could be an empty entry in the contact database
+        # In this case contact.title would report the following error:
+        # File "c:\resource\contacts.py", line 293, in _get_title
+        #   title_str += self._contact.get_field(index)['value'] + u" "
+        # TypeError: unsupported operand types for +: 'NoneType' and 'unicode'
+        #
+        # I think the best way is to ignore such errors...
+        try:
+            self.send(NUM_CONTACTS_REPLY_CONTACT_START,  contact.id,  contact.title)
+        except TypeError:
+            return
+
+        for field in contact:
+            _type = field.type
+            value = field.value
+            value = unicode(value)
+            value = value.replace(u'\u2029',  u'\n') # PARAGRAPH SEPARATOR (\u2029) replaced by LINE FEED (\u000a)
+            location = field.location
+
+            if _type == "unknown":
+                continue
+            elif _type == "thumbnail_image":
+                value = self.getContactThumbnail(contact)
+                if not value:
+                    continue
+            elif _type == "date":
+                value = self.getContactBirthday(contact)
+
+            if isinstance(value, type(None)):
+               continue
+
+            self.send(NUM_CONTACTS_REPLY_CONTACT_LINE,  contact.id,  _type,  location,  value)
+        self.send(NUM_CONTACTS_REPLY_CONTACT_END,  contact.id)
+
+    def modifyContact(self,  modification,  id,  type,  location,  value):
+        try:
+            contact = self.contactDb[id]
+        except:
+            return
+
+        if type == u"thumbnail_image":
+            if modification == "remove":
+                self.setContactThumbnail(contact)
+            else:
+                self.setContactThumbnail(contact,  value)
+            return
+        elif type == u"date":
+            if modification == "remove":
+                self.setContactBirthday(contact)
+            else:
+                self.setContactBirthday(contact,  value)
+            return
+
+        contact.begin()
+
+        if modification == "add":
+            contact.add_field(type,  value,  location=location)
+        elif modification == "remove":
+            index = -1
+            for field in contact.find(type,  location):
+                if field.value == value:
+                    index = field.index
+                    break
+
+            if index != -1:
+                del contact[index]
+
+        contact.commit()
+
+    def getDetailFromVcard(self,  contact,  detail,  delimiter='\r\n'):
+        # This is an ugly hack, needed for some fields that cannot be handled using the contact object
+        try:
+            value = unicode(contact.as_vcard(), 'utf8')
+            value  = value.split(detail + ":")[1].split(delimiter)[0]
+            return value
+        except:
+            return
+
+    def setDetailFromVcard(self,  contact,  detail,  value,  delimiter='\r\n'):
+        # This is an ugly hack, needed for some fields that cannot be handled using the contact object
+        card = contact.as_vcard()
+
+        new = u""
+        for line in card.split("\r\n"):
+            if line.startswith("BEGIN:") or line.startswith("VERSION:") or line.startswith("REV:") or line.startswith("UID:"):
+                new += line + "\r\n"
+
+        # Format value: New line (\r\n) after 64 chars, followed by 4 spaces
+        if len(value) > 64:
+            fmtvalue = "\r\n"
+            for i in range(len(value)/64+1):
+                fmtvalue += value[i*64:(i+1)*64] + "\r\n" + 4*" "
+        else:
+            fmtvalue = value
+
+        new += detail + ":" + fmtvalue + delimiter
+        new += "END:VCARD"
+
+        changed_contact = self.contactDb.import_vcards(new)[0]
+        assert changed_contact.id == contact.id
+
+    def getContactThumbnail(self,  contact):
+        # Ugly workaround!
+        # HACK: The value of type "thumbnail_image" is empty, it is only shown when we export the contact to a vCard
+        image = self.getDetailFromVcard(contact,  "PHOTO;TYPE=JPEG;ENCODING=BASE64",  "\r\n\r\n")
+        if image:
+            image = image.split("\r\n\r\n")[0]
+            image = image.replace("\r",  "").replace("\n",  "").replace(" ",  "")
+            return image
+        return
+
+    def setContactThumbnail(self,  contact,  image=""):
+        # Ugly workaround!
+        # HACK: There seems to be new other way to update/add the contact picture
+        self.setDetailFromVcard(contact,  "PHOTO;TYPE=JPEG;ENCODING=BASE64",  image,  "\r\n\r\n")
+
+    def getContactBirthday(self,  contact):
+        return self.getDetailFromVcard(contact,  "BDAY")
+
+    def setContactBirthday(self,  contact,  date=""):
+        # HACK: It isn't possible to set birthdays < year 1970 (before the beginning of the unix epoch)
+        self.setDetailFromVcard(contact,  "BDAY",  date)
+
+    def __calendarGetType(self,  entry):
+        if isinstance(entry,  calendar.CalendarDb.AnniversaryEntry):
+            return "anniversary"
+        elif isinstance(entry,  calendar.CalendarDb.AppointmentEntry):
+            return "appointment"
+        elif isinstance(entry,  calendar.CalendarDb.EventEntry):
+            return "event"
+        elif isinstance(entry,  calendar.CalendarDb.ReminderEntry):
+            return "reminder"
+        elif isinstance(entry,  calendar.CalendarDb.TodoEntry):
+            return "todo"
+        return ""
+
+    def __calendarFormatEntry(self,  entry,  sep):
+        entryType = self.__calendarGetType(entry)
+        if not entryType:
+            # Type could also be TodoListDict or TodoList, which is currently not handled...
+            return str()
+
+        line = entryType + sep + entry.content + sep + entry.location + sep
+        if entry.start_time:
+            # None if the start datetime of the entry is not set
+            line += str(long(entry.start_time)) # entry.start_time is of type float
+        line += sep
+
+        if entry.end_time:
+            line += str(long(entry.end_time))
+        line += sep
+
+        line += str(long(entry.last_modified)) + sep
+        line += entry.replication + sep  # open, private or restricted
+
+        if entry.alarm:
+            line += str(long(entry.alarm)) # The alarm datetime value (float) for the entry
+        line += sep
+
+        line += str(entry.priority) + sep
+
+        # Format repeat...
+        repeat = entry.get_repeat()
+        repeated = bool(repeat)
+
+        if repeated:
+            line += repeat["type"] # daily, weekly, monthly_by_dates, monthly_by_days, yearly_by_date, yearly_by_day
+        line += sep
+
+        # It is really hard to extract the days...
+        # We try to seperate the values by ',' and different groups by ';'
+        if repeated and "days" in repeat:
+            days = repeat["days"]
+
+            if isinstance(days,  (list,  tuple)):
+                if len(days) == 0:
+                    pass
+                elif isinstance(days[0],  int):
+                    # Which days in week? (0=Monday,...)
+                    # for example: [0,1,2]
+                    line += ",".join([str(day) for day in days])
+                elif isinstance(days[0],  dict):
+                    # example: on second Tuesday and last Monday of the month
+                    # days is: [{'week': 1, 'day': 1}, {'week': 4, 'day': 0}]
+                    # results in: 'week:1,day:1;week:4,day:0'
+                    line += ";".join([",".join([key + ":" + str(value) for key, value in entry.items()]) for entry in days])
+            elif isinstance(days,  dict):
+                # for example: {'week': 1, 'day': 1, 'month': 1}
+                # results in: 'week:1,day:1,month:1'
+                line += ",".join([key + ":" + str(value) for key, value in days.iteritems()])
+        line += sep
+
+        if repeated and "exceptions" in repeat:
+            line += ",".join([str(int(day)) for day in repeat["exceptions"]])
+        line += sep
+
+        if repeated and "start" in repeat:
+            line += str(long(repeat["start"]))
+        line += sep
+
+        if repeated and "end" in repeat:
+            end = long(repeat["end"])
+            end -= time.timezone
+            if end == 4102441200L:
+                # 4102441200L = 2100-01-01T00:00:00
+                # There is a bug in PyS60, which causes that None as end date throws as error
+                # As workarond, we use 2100-01-01 as end date for eternal repeats
+                # Bug report: http://developer.symbian.org/bugs/show_bug.cgi?id=3666
+                end = ""
+            line += str(end)
+        line += sep
+
+        if repeated and "interval" in repeat:
+            line += str(repeat["interval"])
+        line += sep
+
+        if entryType == "todo":
+            # cross out property is valid only for todo entries
+            # a value that is interpreted as false means that the entry is not crossed out
+            line += str(int(bool(entry.crossed_out))) + sep
+
+            if entry.cross_out_time:
+                line += str(long(entry.cross_out_time))
+            line += sep
+
+            # TODO lists no more supported!
+            #line += entry.todo_list + sep  # The ID of the TODO list to which this entry belongs
+
+        return line
+
+    def calendarDict(self):
+        calendarDict = dict()
+        for key in self.calendarDb:
+            entry = self.calendarDb[key]
+            line = self.__calendarFormatEntry(entry,  FIELD_SEP)
+            if not line:
+                continue
+
+            calendarDict[entry.id] =  line
+
+        return calendarDict
+
+    def sendCalendarCount(self):
+        todos = 0
+        calendars = 0
+        for key in self.calendarDb:
+            entry = self.calendarDb[key]
+            entryType = self.__calendarGetType(entry)
+            if entryType in ['todo']:
+                todos = todos + 1
+            elif entryType != '':
+                calendars = calendars + 1
+        self.send(NUM_CALENDAR_REPLY_COUNT, len(self.calendarDb), calendars, todos)
+
+    def sendCalendarHash(self):
+        calendarDict = self.calendarDict()
+
+        keys = calendarDict.keys()
+        keys.sort()
+
+        hash = unicode()
+        for key in keys:
+            hash += str(key)
+            hash += FIELD_SEP
+            hash += calendarDict[key]
+            hash += FIELD_SEP
+            hash += ENTRY_SEP
+
+        #self.send(NUM_DEBUG,  "Mobile:::" + hash.replace(FIELD_SEP,  ";").replace(ENTRY_SEP,  "\n"))
+
+        hash = hash.encode("utf8")
+        hash = md5.md5(hash).hexdigest()
+        self.send(NUM_CALENDAR_REPLY_HASH_ALL, hash)
+
+# We don't need to send a hash for every entry, it's better if we send directly the data
+#    def sendCalendarHashSingle(self):
+#        self.send(NUM_CALENDAR_REPLY_HASH_SINGLE_START)
+#
+#        calendarDict = self.calendarDict()
+#        keys = calendarDict.keys()
+#        keys.sort()
+#
+#        print "keys are of length",  len(keys)
+#
+#        for key in keys:
+#            hash = calendarDict[key]
+#            hash = hash.encode("utf8")
+#            hash = md5.md5(hash).hexdigest()
+#
+#            self.send(NUM_CALENDAR_REPLY_HASH_SINGLE_LINE, key,  hash)
+#
+#        self.send(NUM_CALENDAR_REPLY_HASH_SINGLE_END)
+
+    def sendAllCalendarEntries(self):
+        self.send(NUM_CALENDAR_REPLY_ENTRIES_START)
+        for key in self.calendarDb:
+            entry = self.calendarDb[key]
+            self.sendCalendarEntry(entry )
+        self.send(NUM_CALENDAR_REPLY_ENTRIES_END)
+
+    def sendCalendarEntry(self,  entry):
+        self.send(NUM_CALENDAR_REPLY_ENTRY,  entry.id,  self.__calendarFormatEntry(entry,  NUM_SEPERATOR))
+
+    def modifyCalendarEntry(self,  id,  content,  location,  start,  end,  replication,  alarm,  priority, repeat_type,
+                            repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval):
+
+        try:
+            entry = self.calendarDb[id]
+        except:
+            return
+
+        entry.begin()
+
+        self.modifyCalendarEntryFields(entry,  content,  location,  start,  end,  replication,  alarm,  priority, repeat_type,
+                            repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval)
+
+        entry.commit()
+
+        self.send(NUM_CALENDAR_ENTRY_CHANGE_REPLY_TIME,  id,  str(long(entry.last_modified)))
+
+    def addCalendarEntry(self,  type,  content,  location,  start,  end,  replication,  alarm,  priority, repeat_type,
+                            repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval):
+
+        if type == "appointment":
+            entry = self.calendarDb.add_appointment()
+        elif type == "event":
+            entry = self.calendarDb.add_event()
+        elif type == "anniversary":
+            entry = self.calendarDb.add_anniversary()
+        elif type == "todo":
+            entry = self.calendarDb.add_todo()
+        else:
+            return
+
+        self.modifyCalendarEntryFields(entry,  content,  location,  start,  end,  replication,  alarm,  priority, repeat_type,
+                            repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval)
+
+        entry.commit()
+
+        self.send(NUM_CALENDAR_ENTRY_ADD_REPLY,  entry.id,  str(long(entry.last_modified)))
+
+    def modifyCalendarEntryFields(self,  entry,  content,  location,  start,  end,  replication,  alarm,  priority, repeat_type,
+                            repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval):
+        entry.content = content
+        entry.location = location
+        entry.set_time(start,  end)
+        entry.replication = replication
+        entry.alarm = alarm
+        entry.priority = priority
+
+        # Clear the old repeat
+        entry.set_repeat(None)
+
+        entry.set_repeat(self.buildCalendarEntryRepeat(repeat_type,  repeat_days,  repeat_exceptions,  repeat_start,  repeat_end,  repeat_interval))
+
+    def buildCalendarEntryRepeat(self,   type,  days,  exceptions,  start,  end,  interval):
+        if not type:
+            return None
+        if type not in ("weekly",  "monthly_by_dates",  "monthly_by_days",  "yearly_by_day",  "yearly_by_date"):
+            return None
+
+        days = self.calendarEntryParsedDays(type,  days)
+        if exceptions:
+            exceptions = [float(exception) for exception in exceptions.split(',')]
+        else:
+            exceptions = []
+
+        if end is None:
+            # 4102441200. = 2100-01-01T00:00:00
+            # There is a bug in PyS60, which causes that None as end date throws as error
+            # As workarond, we use 2100-01-01 as end date for eternal repeats
+            # Bug report: http://developer.symbian.org/bugs/show_bug.cgi?id=3666
+            # We also can't use time.mktime([2100, 1, 1, 0, 0, 0, 1, 1, -1]), cause this wouls result in
+            # an integer overflow
+            end = 4102441200.
+
+        # We need to subtract one day from the end date, because
+        # endTime+=TTimeIntervalDays(1);
+        # in calendarmodule.h adds one day after set_repeat is called
+        end -= 24*60*60
+
+        return {"type" : type,
+                      "days" : days,
+                      "exceptions" : exceptions,
+                      "start" : start,
+                      "end" : end,
+                      "interval" : interval}
+
+    def calendarEntryParsedDays(self,  type,  days):
+
+        ### PLEASE COPY CHANGES IN THIS FUNCTION ALSO TO
+        ### pc/lib/classes.py, class CalendarEntry function recurrenceParsedDays
+
+        if type in ("weekly",   "monthly_by_dates"):
+            # 0,1,2 -> [0, 1, 2]
+            return [int(day) for day in days.split(',')]
+        if type == "monthly_by_days":
+            # week:1,day:1;week:4,day:0 -> [{'week': 1, 'day': 1}, {'week': 4, 'day': 0}]
+            dates = []
+            for date in days.split(";"):
+                tmp = dict()
+                for sub in date.split(","):
+                    key, value = sub.split(":")
+                    tmp[key] = int(value)
+                dates.append(tmp)
+            return dates
+        if type == "yearly_by_day":
+            # week:1,day:1,month:1 -> {'week': 1, 'day': 1, 'month': 1}
+            dates = {}
+            for subentry in days.split(","):
+                key,  value = subentry.split(":")
+                dates[key] = int(value)
+            return dates
+
+    def sendOneMessage(self, sms):
+        box = 'inbox'
+        if sms in self.sent.sms_messages():
+            box = 'sent'
+        self.__sendOneMessage(sms, box, NUM_MESSAGE_REPLY_ONE)
+
+    def __sendOneMessage(self, sms, box, code):
+        id = sms
+        try:
+            time = self.inbox.time(sms)
+        except:
+            self.send(code, "")
+            return
+        address = self.inbox.address(sms)
+        content = self.inbox.content(sms)
+        content = content.replace(u'\u2029',  u'\n') # PARAGRAPH SEPARATOR (\u2029) replaced by LINE FEED (\u000a)
+
+        if self.inbox.unread(sms):
+            unread = '1'
+        else:
+            unread = '0'
+
+        self.send(code, box,  id,  time,  address,  content, unread)
+
+    def sendAllMessages(self,  lastId):
+        messages = list()
+        inbox = list()
+        sent = list()
+        for box in ("inbox",  "sent"):
+            #FIXME: I shouldn't need this
+            e32.ao_sleep(1)
+
+            if box == "inbox":
+                inbox = self.inbox.sms_messages()
+            else:
+                sent = self.sent.sms_messages()
+
+        messages = inbox + sent
+        messages.sort()
+        for sms in messages:
+            if (int(sms) > int(lastId)):
+                if sms in inbox:
+                    box = "inbox"
+                else:
+                    box = "sent"
+
+                self.__sendOneMessage(sms, box, NUM_MESSAGE_REPLY_LINE)
+
+        self.send(NUM_MESSAGE_REPLY_END)
+
+    def sendUnreadMessages(self):
+        messages = list()
+        inbox = self.inbox.sms_messages()
+        for sms in inbox:
+            if self.inbox.unread(sms):
+                messages.append(sms)
+        self.send(NUM_MESSAGE_REPLY_UNREAD,  *messages)
+
+    def sendMessagesList(self):
+        inbox = self.inbox.sms_messages() + self.sent.sms_messages()
+        for i in inbox:
+            self.send(NUM_MESSAGE_REPLY_LIST, i)
+        self.send(NUM_MESSAGE_REPLY_END)
+
+    def sendMessagesCount(self):
+        messages = list()
+        inbox = self.inbox.sms_messages() + self.sent.sms_messages()
+        for sms in inbox:
+            if self.inbox.unread(sms):
+                messages.append(sms)
+        self.send(NUM_MESSAGE_REPLY_COUNT, len(inbox), len(messages))
+
+    def sendMessage(self, name, phone, encoding,  msg):
+        try:
+            messaging.sms_send(phone, msg,  encoding,  self.sentMessage,  name)
+        except RuntimeError,  detail:
+            if str(detail) == "Already sending":
+                # Workaround for the "Already sending" bug:
+                # http://discussion.forum.nokia.com/forum/showthread.php?t=141083
+                messaging._sending = False
+                self.send(NUM_MESSAGE_SEND_REPLY_RETRY,  str(detail) + "; tried workaround")
+            else:
+                self.send(NUM_MESSAGE_SEND_REPLY_RETRY,  detail)
+
+    def sentMessage(self,  status):
+        if status == messaging.ECreated:
+            self.send(NUM_MESSAGE_SEND_REPLY_STATUS,  "Message created.")
+        elif status == messaging.EMovedToOutBox:
+            self.send(NUM_MESSAGE_SEND_REPLY_STATUS,  "Moved to outbox.")
+        elif status == messaging.EScheduledForSend:
+            self.send(NUM_MESSAGE_SEND_REPLY_STATUS,  "Scheduled for send.")
+        if status == messaging.ESent:
+            self.send(NUM_MESSAGE_SEND_REPLY_STATUS,  "Message sent.")
+        elif status == messaging.EDeleted:
+            self.send(NUM_MESSAGE_SEND_REPLY_OK,  "The SMS message has been deleted from device's outbox queue.")
+        elif status == messaging.EScheduleFailed:
+            self.send(NUM_MESSAGE_SEND_REPLY_FAILURE,  "Schedule failed.")
+        elif status == messaging.ESendFailed:
+            self.send(NUM_MESSAGE_SEND_REPLY_FAILURE,  "The SMS subsystem has tried to send the message several times in vain.")
+        elif status == messaging.ENoServiceCentre:
+            self.send(NUM_MESSAGE_SEND_REPLY_FAILURE,  "No service centre.")
+        elif status == messaging.EFatalServerError:
+            self.send(NUM_MESSAGE_SEND_REPLY_FAILURE,  "SMS send failed! If the device is in offline-mode or with no network connection the message is added to the device's outgoing message queue.")
+
+    def newMessage(self, sms):
+        if not self.connected:
+            return
+
+        #FIXME: I shouldn't need this
+        e32.ao_sleep(1)
+
+        id = sms
+        time = self.inbox.time(sms)
+        address = self.inbox.address(sms)
+        content = self.inbox.content(sms)
+
+        self.send(NUM_MESSAGE_NEW, id,  time,  address,  content)
+
+    def handleCall(self,  handle):
+        state = handle[0]
+        number = handle[1]
+        call_state = { telephone.EStatusUnknown: "unknown",
+        telephone.EStatusIdle: "idle",
+        telephone.EStatusDialling: "dialing",
+        telephone.EStatusRinging: "ringing",
+        telephone.EStatusAnswering: "answering",
+        telephone.EStatusConnecting: "connecting",
+        telephone.EStatusConnected: "connected",
+        telephone.EStatusReconnectPending: "reconnect pending",
+        telephone.EStatusDisconnecting: "disconnecting",
+        telephone.EStatusHold: "hold",
+        telephone.EStatusTransferring: "transferring",
+        telephone.EStatusTransferAlerting: "transfer alerting" }
+
+        self.send(NUM_INCOMING_CALL, number,  call_state[state])
+
+    def messageDelete(self,  id):
+        self.inbox.delete(id)
+
+    def setRead(self,  id,  state):
+        state = int(not state)
+
+        #FIXME: I shouldn't need this
+        e32.ao_sleep(1)
+
+        self.inbox.set_unread(id,  state)
+
+    def quit(self):
+        self.stopService()
+        self.disconnect()
+
+    def exitHandler(self):
+        self.quit()
+        self.saveConfig()
+
+        app.exit_key_handler = None
+        self.lock.signal()
+        if self.useCanvas:
+            self.canvas = None
+        if app.full_name()[-10:] != "Python.app":
+           app.set_exit()
+
+    def portHandler(self):
+        ret = query(u'Enter bluetooth port to use', 'number', self.port)
+        if ret is not None:
+            self.port = ret
+            self.quit()
+            self.saveConfig()
+            self.startService()
+
+    def aboutHandler(self):
+        query(u'Series60 - remote\nVersion %s\nModified for Gammu\nhttp://wammu.eu/' % (VERSION) , 'query')
+
+    def toggleHandler(self):
+        e32.start_exe(u'BtToggleApp.exe','')
+
+# Debug of SIS applications
+try:
+    mobile = Mobile()
+except Exception, e:
+    # Oops, something wrong. Report problems to user
+    # and ask him/her to send them to you.
+    import traceback
+
+    new_line = u"\u2029"
+
+    # Collecting call stack info
+    info = sys.exc_info()
+
+    # Show the last 4 lines of the call stack
+    call_stack = u""
+    for filename, lineno, function, text in traceback.extract_tb(info[2]):
+        call_stack += filename + u": " + str(lineno) + u" - " + function + new_line
+        call_stack += u" " + repr(text) + new_line
+    call_stack +=  u"%s: %s" % info[:2]
+
+    # Creating a friendly user message with exception details
+    err_msg = u"This programs was unexpectedly closed due to the following error: "
+    err_msg += unicode(repr(e)) + new_line
+    err_msg += u"Please, copy and paste the text presented here and "
+    err_msg += u"send it to series60-remote-devel@lists.sourceforge.net. "
+    err_msg += u"Thanks in advance and sorry for this inconvenience." + new_line*2
+    err_msg += u"Call stack:" + new_line + call_stack
+
+    # Small PyS60 application
+    lock = e32.Ao_lock()
+    app.body = Text(err_msg)
+    app.body.set_pos(0)
+    app.menu = [(u"Exit", lambda: lock.signal())]
+    lock.wait()
diff --git a/contrib/s60/icon.svg b/contrib/s60/icon.svg
new file mode 100644
index 0000000..5c1cca5
--- /dev/null
+++ b/contrib/s60/icon.svg
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>

+<!-- Generator: Adobe Illustrator 14.0.0, SVG Export Plug-In  -->

+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Tiny//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-tiny.dtd" [

+	<!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/">

+]>

+<svg version="1.1" baseProfile="tiny"

+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"

+	 x="0px" y="0px" width="32px" height="32px" viewBox="-7 -1 32 32" xml:space="preserve">

+<defs>

+</defs>

+<path id="rect2334_1_" d="M1.547,0h13.906C16.311,0,17,0.69,17,1.547v25.906C17,28.311,16.311,29,15.453,29C15,29,14,30,9,30

+	c-6,0-7-1-7.453-1C0.69,29,0,28.311,0,27.453V1.547C0,0.69,0.69,0,1.547,0z"/>

+<image width="15" height="28" id="rect2336_1_" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA8AAAAcCAYAAAC+lOV/AAAACXBIWXMAAAsSAAALEgHS3X78AAAA
+GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAD1JREFUeNpiNDIy+s/CwsLAzMzM
+gEzD2ExMTAy4AG4ZIsCo5lHNo5pHNY9qHkmaz507x0iOxs2bNzMCBBgA9owGoySwoYEAAAAASUVO
+RK5CYII=" transform="matrix(1 0 0 1 1 1)">

+</image>

+<rect id="rect2971_1_" x="1" y="1" fill="#6B6B6B" width="15" height="18"/>

+<image width="13" height="15" id="rect2927_1_" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA0AAAAPCAIAAACwQdIgAAAACXBIWXMAAAsSAAALEgHS3X78AAAA
+GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAALJJREFUeNpkkGsOwyAMg3Hg1Dvd
+7rQf7VRUmgeEQKUKRZG/2DU+3x9RykiZGsEGfhu/pLO+rRwVJspAB9CI4IAuUc4Legm67TeCSACW
++r1oDTfNw5rv8dQh33qSme+soJndgZnEANHpVq5GwGcDynEheC0iGg6iO2sIvjeCkbhJL9QbmXRs
+xBzWnl92Pi89m/UmMpjv9Xyj5x0w6/LX/uhV7PZzJaV0N/nqvQAUSublI8AA5CNLm6PQ5OwAAAAA
+SUVORK5CYII=" transform="matrix(1 0 0 1 2 3)">

+</image>

+<image width="13" height="11" id="rect2956_1_" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA0AAAALCAYAAACksgdhAAAACXBIWXMAAAsSAAALEgHS3X78AAAA
+GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAGdJREFUeNpi/P//fw4DA8M/IP4P
+xH+h9D8cGCzHAiR+EFCEYRBI03dCitAxTBM+xRhy2JxH0DZk59EuIBgZGe+QFBBADY+BNAPRAQHU
+8IoBCvA5D24QUMMHBiSAMyCACj8z4AAAAQYAodqEAMks1JsAAAAASUVORK5CYII=" transform="matrix(1 0 0 1 2 3)">

+</image>

+<image width="11" height="8" id="rect2975_1_" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAICAYAAAAvOAWIAAAACXBIWXMAAAsSAAALEgHS3X78AAAA
+GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAB9JREFUeNpi/P//PxcDkYAFiNlJ
+UcwxBE2mjTMAAgwAdgUDWVl80nYAAAAASUVORK5CYII=" transform="matrix(1 0 0 1 3 19)">

+</image>

+<rect id="rect2985_1_" x="3" y="23" fill="#252525" width="11" height="1"/>

+<rect id="rect2987_1_" x="2.5" y="3.5" fill="none" stroke="#001C3F" stroke-width="1" stroke-linecap="round" width="12" height="14"/>

+<rect id="rect2989_1_" x="3" y="21" fill="#252525" width="11" height="1"/>

+<rect id="rect2991_1_" x="6" y="19" fill="#252525" width="1" height="8"/>

+<rect id="rect2993_1_" x="10" y="19" fill="#252525" width="1" height="8"/>

+<rect id="rect2362_1_" x="3" y="19" fill="#252525" width="11" height="1"/>

+<path id="path2961_1_" fill="#FFFFFF" d="M2,1.302C2,1.688,1.688,2,1.302,2C0.917,2,0.604,1.688,0.604,1.302

+	c0-0.385,0.313-0.698,0.698-0.698C1.688,0.604,2,0.917,2,1.302z"/>

+<image width="16" height="1" id="rect2963_1_" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAABCAYAAADXeS5fAAAACXBIWXMAAAsSAAALEgHS3X78AAAA
+GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAACxJREFUeNpiZACC////8wApXiDm
+gWIYmxuI2YH4JxB/BeIvQPwZSoPZAAEGABfsCgtHFqsoAAAAAElFTkSuQmCC" transform="matrix(1 0 0 1 1 18)">

+</image>

+<path id="path2974_1_" fill="#FFFFFF" d="M16.5,1.302C16.5,1.688,16.188,2,15.802,2s-0.698-0.313-0.698-0.698

+	c0-0.385,0.313-0.698,0.698-0.698S16.5,0.917,16.5,1.302z"/>

+<path id="path2976_1_" fill="#FFFFFF" d="M1.75,29.052c0,0.386-0.313,0.698-0.698,0.698c-0.385,0-0.698-0.313-0.698-0.698

+	s0.313-0.698,0.698-0.698C1.438,28.354,1.75,28.666,1.75,29.052z"/>

+<path id="path2978_1_" fill="#FFFFFF" d="M16.75,29.052c0,0.386-0.313,0.698-0.698,0.698s-0.698-0.313-0.698-0.698

+	s0.313-0.698,0.698-0.698S16.75,28.666,16.75,29.052z"/>

+<rect id="rect2446_1_" x="3" y="25" fill="#252525" width="11" height="1"/>

+<rect id="rect3248_1_" x="4" y="1" width="9" height="1"/>

+<rect id="rect3246_1_" x="5" y="1" width="7" height="1"/>

+<rect id="rect3218_1_" x="6" y="1" width="5" height="1"/>

+<rect id="rect3222_1_" x="5" y="20" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3224_1_" x="9" y="20" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3226_1_" x="13" y="20" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3228_1_" x="5" y="22" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3230_1_" x="9" y="22" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3232_1_" x="13" y="22" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3234_1_" x="5" y="24" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3236_1_" x="9" y="24" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3238_1_" x="13" y="24" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3240_1_" x="5" y="26" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3242_1_" x="9" y="26" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3244_1_" x="13" y="26" fill="#BFD9FF" width="1" height="1"/>

+<rect id="rect3250_1_" x="6" y="1" fill="#C3C3C3" width="1" height="1"/>

+<rect id="rect3252_1_" x="8" y="1" fill="#C3C3C3" width="1" height="1"/>

+<rect id="rect3254_1_" x="10" y="1" fill="#C3C3C3" width="1" height="1"/>

+</svg>

diff --git a/contrib/s60/series60-remote-sign.sis b/contrib/s60/series60-remote-sign.sis
new file mode 100644
index 0000000..7942dac
--- /dev/null
+++ b/contrib/s60/series60-remote-sign.sis
diff --git a/contrib/s60/series60-remote.sis b/contrib/s60/series60-remote.sis
new file mode 100644
index 0000000..47ded46
--- /dev/null
+++ b/contrib/s60/series60-remote.sis
diff --git a/contrib/s60/status_numbers.py b/contrib/s60/status_numbers.py
new file mode 100644
index 0000000..1c1ea4a
--- /dev/null
+++ b/contrib/s60/status_numbers.py
@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2008 - 2010 Lukas Hetzenecker <LuHe@gmx.at>
+
+NUM_CONNECTED = 100
+NUM_HELLO_REQUEST = 110
+NUM_HELLO_REPLY = 111
+NUM_QUIT = 120
+NUM_PARTIAL_MESSAGE = 130
+
+NUM_CONTACTS_REQUEST_HASH_ALL = 200
+NUM_CONTACTS_REQUEST_HASH_SINGLE= 201
+NUM_CONTACTS_REQUEST_COUNT = 202
+NUM_CONTACTS_REQUEST_CONTACT = 204
+NUM_CONTACTS_REQUEST_CONTACTS_ALL = 205
+NUM_CONTACTS_REPLY_HASH_ALL= 210
+NUM_CONTACTS_REPLY_HASH_SINGLE_START= 211
+NUM_CONTACTS_REPLY_HASH_SINGLE_LINE= 212
+NUM_CONTACTS_REPLY_HASH_SINGLE_END= 213
+NUM_CONTACTS_REPLY_COUNT = 214
+NUM_CONTACTS_REPLY_CONTACT_START = 220
+NUM_CONTACTS_REPLY_CONTACT_LINE = 221
+NUM_CONTACTS_REPLY_CONTACT_END = 222
+NUM_CONTACTS_REPLY_CONTACTS_ALL_END = 223
+NUM_CONTACTS_REPLY_CONTACT_NOT_FOUND = 224
+NUM_CONTACTS_ADD = 230
+NUM_CONTACTS_ADD_REPLY_ID = 231
+NUM_CONTACTS_DELETE = 232
+NUM_CONTACTS_CHANGE_ADDFIELD = 233
+NUM_CONTACTS_CHANGE_REMOVEFIELD = 234
+
+NUM_SYSINFO_REQUEST = 250
+NUM_SYSINFO_REPLY_START = 260
+NUM_SYSINFO_REPLY_LINE = 261
+NUM_SYSINFO_REPLY_END = 262
+
+NUM_LOCATION_REQUEST = 270
+NUM_LOCATION_REPLY = 271
+NUM_LOCATION_REPLY_NA = 272
+
+NUM_DIAL = 280
+NUM_HANGUP = 281
+
+NUM_MESSAGE_SEND_REQUEST = 300
+NUM_MESSAGE_SEND_REPLY_OK = 301
+NUM_MESSAGE_SEND_REPLY_STATUS = 302
+NUM_MESSAGE_SEND_REPLY_FAILURE = 303
+NUM_MESSAGE_SEND_REPLY_RETRY = 304
+NUM_SET_READ = 320
+NUM_MESSAGE_DELETE = 321
+
+NUM_MESSAGE_NEW = 350
+NUM_MESSAGE_REQUEST = 351
+NUM_MESSAGE_REPLY_LINE = 352
+NUM_MESSAGE_REPLY_END = 353
+
+NUM_MESSAGE_REQUEST_UNREAD = 370
+NUM_MESSAGE_REPLY_UNREAD = 371
+
+NUM_MESSAGE_REQUEST_LIST = 372
+NUM_MESSAGE_REPLY_LIST = 373
+
+NUM_MESSAGE_REQUEST_COUNT = 374
+NUM_MESSAGE_REPLY_COUNT = 375
+
+NUM_MESSAGE_REQUEST_ONE = 376
+NUM_MESSAGE_REPLY_ONE = 377
+
+NUM_CALENDAR_REQUEST_COUNT = 378
+NUM_CALENDAR_REPLY_COUNT = 379
+
+NUM_CALENDAR_REQUEST_HASH_ALL = 380
+#NUM_CALENDAR_REQUEST_HASH_SINGLE = 381
+NUM_CALENDAR_REQUEST_ENTRY = 382
+NUM_CALENDAR_REQUEST_ENTRIES_ALL = 383
+NUM_CALENDAR_REPLY_HASH_ALL= 384
+#NUM_CALENDAR_REPLY_HASH_SINGLE_START= 385
+#NUM_CALENDAR_REPLY_HASH_SINGLE_LINE= 386
+#NUM_CALENDAR_REPLY_HASH_SINGLE_END= 387
+NUM_CALENDAR_REPLY_ENTRIES_START = 388
+NUM_CALENDAR_REPLY_ENTRY = 389
+NUM_CALENDAR_REPLY_ENTRIES_END = 390
+NUM_CALENDAR_REPLY_ENTRY_NOT_FOUND = 391
+NUM_CALENDAR_ENTRY_ADD = 395
+NUM_CALENDAR_ENTRY_ADD_REPLY = 396
+NUM_CALENDAR_ENTRY_DELETE = 397
+NUM_CALENDAR_ENTRY_CHANGE = 398
+NUM_CALENDAR_ENTRY_CHANGE_REPLY_TIME = 399
+
+NUM_INCOMING_CALL = 400
+
+NUM_SCREENSHOT = 900
+NUM_SCREENSHOT_REPLY = 901
+
+NUM_DEBUG = 999
+
+NUM_END_HEADER = chr(0x02)   # Start of Text
+NUM_SEPERATOR = chr(0x1E)   # Record Separator
+NUM_END_TEXT = chr(0x03)   # End of Text
+
+PROTOCOL_VERSION = 1.5
diff --git a/contrib/sms-gammu2android/LICENSE b/contrib/sms-gammu2android/LICENSE
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/contrib/sms-gammu2android/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/contrib/sms-gammu2android/README b/contrib/sms-gammu2android/README
new file mode 100644
index 0000000..9dc0cc6
--- /dev/null
+++ b/contrib/sms-gammu2android/README
@@ -0,0 +1,18 @@
+Nokia To Android SMS Converter
+Copyright (C) 2009 Thilo-Alexander Ginkel <thilo@ginkel.com>
+
+For instructions, refer to:
+http://blog.ginkel.com/2009/12/transferring-sms-from-nokia-to-android/
+
+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 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
diff --git a/contrib/sms-gammu2android/sms-gammu2android b/contrib/sms-gammu2android/sms-gammu2android
new file mode 100755
index 0000000..77aec8d
--- /dev/null
+++ b/contrib/sms-gammu2android/sms-gammu2android
@@ -0,0 +1,109 @@
+#!/usr/bin/perl
+
+# Nokia To Android SMS Converter
+# Copyright (C) 2009 Thilo-Alexander Ginkel <thilo@ginkel.com>
+#
+# For instructions, refer to:
+# http://blog.ginkel.com/2009/12/transferring-sms-from-nokia-to-android/
+#
+# 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 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use Date::Parse;
+use HTML::Entities;
+
+print <<HEADER;
+<?xml version='1.0' encoding='UTF-8' standalone='yes' ?>
+<smses>
+HEADER
+
+while (<>) {
+	chomp;
+	s/^(.*)\r$/$1/;
+
+	if (/^DateTime = (.*)/) {
+		$time = str2time($1);
+	} elsif (/^Number = "(.*)"/) {
+		$address = $1;
+	} elsif (/^UDH = 050003(.*)(\p{XDigit}{2})/) {
+		$msgid = $1;
+		$seqno = $2;
+	} elsif (/^State = (.*)/) {
+		if ($1 eq "Sent") {
+			$type = 2;
+		} elsif ($1 eq "Read") {
+			$type = 1;
+		}
+	} elsif (/^Text\d+ = (.*)/) {
+		my $encoded = $1;
+		$encoded =~ s/([0-9A-F]{4})/&utf8(hex($1))/gei;
+		$text .= $encoded;
+		# print $text, "\n";
+	} elsif (/^$/ and defined($address)) {
+		unless ($msgid) {
+			print_message($address, $time, $type, $text);
+		} else {
+			my $msg = {};
+			my $parts = {};
+
+			$id = $address . $msgid;
+
+			if (defined($multipart{$id})) {
+				$msg = $multipart{$id};
+			} else {
+				$msg->{'date'} = $time;
+				$msg->{'address'} = $address;
+				$msg->{'type'} = $type;
+			}
+
+			if (defined($msg->{'parts'})) {
+				$parts = $msg->{'parts'};
+			}
+
+			$parts->{$seqno} = $text;
+
+			$msg->{'parts'} = $parts;
+			$multipart{$id} = $msg;
+		}
+
+		$time = undef;
+		$address = undef;
+		$msgid = undef;
+		$seqno = undef;
+		$type = undef;
+		$text = undef;
+	}
+}
+
+# output any multipart messages
+foreach $msg (values %multipart) {
+	my $body;
+	my $parts = $msg->{'parts'};
+	foreach $seqno (sort keys %$parts) {
+		$body .= $parts->{$seqno};
+	}
+	print_message($msg->{'address'}, $msg->{'date'}, $msg->{'type'}, $body);
+}
+
+print "</smses>\n";
+
+sub utf8 { local($_)=@_;
+    return $_ < 0x80 ? chr($_) : 
+	$_ < 0x800 ? chr($_>>6&0x3F|0xC0) . chr($_&0x3F|0x80) :
+	    chr($_>>12&0x0F|0xE0).chr($_>>6&0x3F|0x80).chr($_&0x3F|0x80);
+}
+
+sub print_message {
+	my ($address, $date, $type, $text) = @_;
+	print "<sms protocol=\"0\" address=\"" . encode_entities($address, "<>&'\"") . "\" date=\"${date}000\" type=\"$type\" subject=\"null\" body=\"" . encode_entities($text, "<>&'\"") . "\" toa=\"null\" sc_toa=\"null\" service_center=\"\" read=\"1\" status=\"-1\" />\n";
+}