Merge lp:~sanyok-og/nfcpy/dev-dbus into lp:nfcpy

[Alexander Knaub]

Added a D-Bus server and 2 clients to the examples.
D-Bus configuration is described in the comments inside.

[Stephen Tiedemann (stephen-tiedemann)]

review: Approve

=== added directory 'examples/dbus_examples'
=== added file 'examples/dbus_examples/dbus_readerwriter.py'
--- examples/dbus_examples/dbus_readerwriter.py	1970-01-01 00:00:00 +0000
+++ examples/dbus_examples/dbus_readerwriter.py	2011-01-04 16:28:41 +0000
@@ -0,0 +1,328 @@
+# -----------------------------------------------------------------------------
+# Copyright 2010, 2011 Alexander Knaub <[e-mail]>
+#
+# Licensed under the EUPL, Version 1.1 or - as soon they 
+# will be approved by the European Commission - subsequent
+# versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the
+# Licence.
+# You may obtain a copy of the Licence at:
+#
+# http://ec.europa.eu/idabc/eupl
+#
+# Unless required by applicable law or agreed to in
+# writing, software distributed under the Licence is
+# distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied.
+# See the Licence for the specific language governing
+# permissions and limitations under the Licence.
+# -----------------------------------------------------------------------------
+
+
+# Usage Notes start -----------------------------------------------------------
+# This file implements the basic NFC Type3Tag-operations and offers an 
+#     interface via D-Bus. 
+# This interface includes methods to write NDEF-Data to a tag (WriteNDEF) and 
+#     format a tag (FormatTag). 
+#     Also it contains D-Bus-Signals to inform the listeners about newly read
+#     tag (TagInfo) and the message contained in this tag (NDEFMessage) in form 
+#     of byte arrays.
+#
+# Before starting to use this module, you have to configure your system D-Bus:
+#  1) Create a file with the name like "org.nfcpy.Tagreader.conf" with 
+#     following content:
+#
+#    <?xml version="1.0" encoding="UTF-8"?> <!-- -*- XML -*- -->
+#    <!DOCTYPE busconfig PUBLIC
+#    "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+#    "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+#    <busconfig>
+#        <servicedir>/usr/share/dbus-1/system-services/</servicedir>
+#        <policy context="default">
+#            <!-- Root can connect to system bus -->
+#            <allow user="root"/>
+#    
+#            <!-- Holes are punched here for
+#             name ownership and sending method calls -->
+#            <allow own="org.nfcpy.TagReader"/>
+#            <allow send_type="method_call"/>
+#        </policy>
+#    </busconfig>
+#
+#  2) Place this file in the folder "/etc/dbus-1/system.d/". Note that you 
+#     will need root rights for this. You can use the following command: 
+#    sudo cp org.nfcpy.Tagreader.conf /etc/dbus-1/system.d/org.nfcpy.Tagreader.conf
+#
+#  3) Reboot your computer to start D-Bus with new configuration.
+#
+# Usage Notes end--------------------------------------------------------------
+import logging
+log = logging.getLogger("nfcpy.reader")
+import time
+import gobject
+import pickle
+from threading import Thread
+import dbus.service
+import dbus.mainloop.glib
+#nfc package is 2 levels higher in the file system:
+import sys, os
+_above_folder = os.path.split(sys.path[0])[0]
+sys.path.insert(1, os.path.split(_above_folder)[0])
+import nfc.dev
+from nfc.ndef.Message import Message
+ 
+BUS_NAME = "org.nfcpy.TagReader"
+
+def tt3_format(tag):
+    log.debug("Formatting...")
+    def determine_block_count(tag):
+        block = 0
+        try:
+            while True:
+                data = tag.read([block], 9)
+                block += 1
+        except Exception:
+            if tag.pmm[0:2] == "\x00\xF0":
+                block -= 1 # last block on FeliCa Lite is unusable
+            return block
+
+    def determine_block_read_count(tag, block_count):
+        try:
+            for i in range(block_count):
+                tag.read(range(i+1))
+        except Exception: return i
+
+    def determine_block_write_count(tag, block_count):
+        try:
+            for i in range(block_count):
+                data = ((i+1)*16) * "\x00"
+                tag.write(data, range(i+1))
+        except Exception: return i
+
+    block_count = determine_block_count(tag)
+    log.debug("tag has %d user data blocks" % block_count)
+
+    nbr = determine_block_read_count(tag, block_count)
+    log.debug("%d block(s) can be read at once" % nbr)
+
+    nbw = determine_block_write_count(tag, block_count)
+    log.debug("%d block(s) can be written at once" % nbw)
+
+    nmaxb_msb = (block_count - 1) / 256
+    nmaxb_lsb = (block_count - 1) % 256
+    attr = [0x10, nbr, nbw, nmaxb_msb, nmaxb_lsb, 
+            0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+    csum = sum(attr[0:14])
+    attr[14] = csum / 256
+    attr[15] = csum % 256
+
+    log.debug("writing attribute data block:")
+    print " ".join(["%02x" % x for x in attr])
+
+    attr = ''.join([chr(b) for b in attr])
+    tag.write(attr, [0])
+    log.debug("Successful")
+
+class TagReader(dbus.service.Object):
+    def __init__(self, bus, mainloop, path="/nfcpy/tagreader"):
+        log.debug("READER: Create Reader/Writer object...")
+        self.running = False
+        dbus.service.Object.__init__(self, conn=bus, object_path=path)
+        if bus.name_has_owner(BUS_NAME):
+            # Another instance exists. Inform user and exit.
+            owner = bus.get_name_owner(BUS_NAME)
+            log.warning("READER: Another instance is running. You can access " 
+                     + "or exit it via DBus by the name 'org.nfcpy.TagReader'" 
+                     + "or by the unique name " + owner + ".")
+            return
+        log.debug("READER: Request Service name")
+        req_responce = bus.request_name(BUS_NAME,
+                                        dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
+        # debugging:
+        if req_responce == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
+            log.debug("READER: reply: exists. %s" % req_responce)
+        elif req_responce == dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER:
+            log.debug("READER: reply: primary owner. %s" % req_responce)
+
+        self._mainloop = mainloop
+        self._message = None
+        self._last_tag = dict()
+        self._exit_reading = False
+        self._pause_reading = False
+        self._last_idm = None
+        self._clf = None
+        read_thread = Thread(target=self.read_loop, name="ReadThread")
+        read_thread.start()
+        self.running = True
+        
+    @property
+    def running(self):
+        return self._running
+    
+    @running.setter
+    def running(self, value):
+        self._running = value
+        
+    @dbus.service.signal(dbus_interface='org.nfcpy.TagReader',
+                         signature='ay') # byte-array, subclass of str
+    def NDEFMessage(self, new_message_string):
+        log.debug("READER: Emit message!")
+        if new_message_string:
+            return new_message_string
+        else:
+            return ""
+    
+    @dbus.service.signal(dbus_interface='org.nfcpy.TagReader',
+                         signature='ay') # byte-array, subclass of str
+    def TagInfo(self, tag_str):
+        log.debug("READER: Emit Tag Info!")
+#        return new_message_string
+
+    @dbus.service.method('org.nfcpy.TagReader', in_signature="", 
+                         out_signature="")
+    def Exit(self):
+        log.info("READER: exiting...")
+        self._exit_reading = True
+        log.debug("READER: release connection to" + str(self.connection))
+        self.connection.release_name(BUS_NAME)
+        log.debug("READER: Stop the mainloop")
+        self._mainloop.quit()
+        log.debug("READER: End program")
+        
+    @dbus.service.method('org.nfcpy.TagReader', in_signature="ay", 
+                         out_signature="", byte_arrays=True)
+    def WriteNDEF(self, message_string):
+        log.info("WRITER: Writting...")
+        self._pause_reading = True
+        self._message = Message(str(message_string))
+        log.info("WRITER: Write message with type " + self._message.type)
+        if not self._clf:
+            try:
+                self._clf = nfc.ContactlessFrontend(probe=nfc.dev.__all__)
+            except LookupError:
+                log.warning("WRITER: Reader/Writer not found. Exiting")
+                self.Exit()
+        tag = None
+        while not tag:
+            tag = self._clf.poll(general_bytes = None)
+        
+        if tag: 
+            log.debug("WRITER: found tag with IDm " + tag.idm)
+            tag.ndef.message = self._message.tostring()
+            log.debug("WRITER: Writing successfully finished.")
+        else:
+            log.info("WRITER: No tag found...")
+        self._pause_reading = False
+        return
+        
+    @dbus.service.method('org.nfcpy.TagReader', in_signature="", 
+                         out_signature="b")
+    def FormatTag(self):
+        self._pause_reading = True
+        if not self._clf:
+            try:
+                self._clf = nfc.ContactlessFrontend(probe=nfc.dev.__all__)
+            except LookupError:
+                log.warning("WRITER: Reader/Writer not found. Exiting")
+                self.Exit()
+        
+        tag = None
+        while not tag:
+            try:
+                tag = self._clf.poll(general_bytes = None)
+            except KeyboardInterrupt:
+                log.warning("WRITER: Aborted by user. Exit formatting...")
+                return False
+        log.info("Tag found: " + str(tag))
+        if tag:
+            log.info(str(tag))
+            if isinstance(tag, nfc.Type3Tag):
+                tt3_format(tag)
+                success = True
+            else:
+                print "unable to format {0}".format(str(tag))
+                self._pause_reading = False
+                success = False
+        else:
+            print "No tag"
+        self._pause_reading = False
+        return success
+
+    def read_loop(self):
+        log.debug("READER: start new reading loop...")
+        if not self._clf:
+            try:
+                self._clf = nfc.ContactlessFrontend(probe=nfc.dev.__all__)
+                log.debug("READER: CLF found: " + str(self._clf))
+            except LookupError:
+                log.warning("READER: Reader device not found. Exiting")
+                self.Exit()
+                return
+        try:
+            log.debug("READER: Now start reading")
+            while not self._exit_reading:
+                if not self._pause_reading:
+                    tag = self._clf.poll(general_bytes = None)
+                else:
+                    tag = None
+                if not tag:
+                    time.sleep(0.5)
+                    continue
+                if isinstance(tag, nfc.Type3Tag):
+                    log.debug("READER: New tag found: " + str(tag))
+                    last_tag = {'idm': tag.idm,
+                                'pmm': tag.pmm}
+                    if tag.ndef is not None:
+                        log.debug("READER: NDEF is present")
+                        self._last_idm = tag.idm
+                        last_tag['version'] = tag.ndef.version
+                        last_tag['writeable'] = tag.ndef.writeable
+                        last_tag['capacity'] = tag.ndef.capacity
+                        last_tag['size'] = len(tag.ndef.message)
+
+                        self._message = Message(tag.ndef.message)
+                        log.debug("READER: NDEF Message detected: ")
+                        log.debug("READER:     type=%s" 
+                                  % self._message.type)
+                        if last_tag['size']:
+                            log.debug("READER: size: %d" % last_tag['size'])
+                            self.NDEFMessage(tag.ndef.message) # emit
+                        self.TagInfo(pickle.dumps(last_tag))
+                
+                while tag.is_present:
+                    time.sleep(1)
+                log.debug("READER: Tag removed")
+
+        except IOError:
+            log.warning("READER: IO Error occured. restarting...")
+            read_thread = Thread(target=self.read_loop, name="ReadThread")
+            read_thread.start()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format='%(message)s')
+    logging.getLogger("nfc").setLevel(logging.INFO)
+    log.setLevel(logging.DEBUG)
+    
+    # enable threads besides the mainloop
+    gobject.threads_init()
+    dbus.mainloop.glib.threads_init()
+    log.debug("Threading initialised")
+    # initialise TagReader:
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+    bus = dbus.SystemBus() #SystemBus()
+    loop = gobject.MainLoop()
+    reader = TagReader(bus, loop)
+    if reader.running:
+        log.debug("Reader object created")
+        try:
+            log.debug("Starting...")
+            loop.run()
+        except KeyboardInterrupt:
+            log.info("READER: Aborted by user!")
+            reader.Exit()
+    else:
+        log.debug("READER: Initialisation failed. Exiting...")
+        
+    

=== added file 'examples/dbus_examples/read_tag.py'
--- examples/dbus_examples/read_tag.py	1970-01-01 00:00:00 +0000
+++ examples/dbus_examples/read_tag.py	2011-01-04 16:28:41 +0000
@@ -0,0 +1,235 @@
+# -----------------------------------------------------------------------------
+# Copyright 2011 Alexander Knaub <[e-mail]>
+#
+# Licensed under the EUPL, Version 1.1 or - as soon they 
+# will be approved by the European Commission - subsequent
+# versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the
+# Licence.
+# You may obtain a copy of the Licence at:
+#
+# http://ec.europa.eu/idabc/eupl
+#
+# Unless required by applicable law or agreed to in
+# writing, software distributed under the Licence is
+# distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied.
+# See the Licence for the specific language governing
+# permissions and limitations under the Licence.
+# -----------------------------------------------------------------------------
+
+import logging
+log = logging.getLogger()
+
+import os
+import sys
+import time
+import string
+import pickle
+import gobject
+import dbus.mainloop.glib
+
+sys.path.insert(1, os.path.split(sys.path[0])[0])
+import nfc.ndef
+from nfc.ndef.SmartPoster import SmartPosterRecord
+from nfc.ndef.ConnectionHandover import HandoverSelectMessage
+from nfc.ndef.WiFiSimpleConfig import WiFiConfigData, WiFiPasswordData
+from nfc.ndef.BluetoothEasyPairing import BluetoothConfigData
+
+BUS_NAME = "org.nfcpy.TagReader"
+
+def make_printable(data):
+    printable = string.digits + string.letters + string.punctuation + ' '
+    return ''.join([c if c in printable else '.' for c in data])
+
+def format_data(data):
+    s = []
+    for i in range(0, len(data), 16):
+        s.append("  %04x: " % i)
+        s[-1] += ' '.join(["%02x" % ord(c) for c in data[i:i+16]]) + ' '
+        s[-1] += (8 + 16*3 - len(s[-1])) * ' '
+        s[-1] += make_printable(data[i:i+16])
+    return '\n'.join(s)
+
+def print_smartposter(message):
+    print "Smart Poster"
+    sp = SmartPosterRecord(message[0])
+    for lang in sorted(sp.title):
+        print "  title[%s] = %s" % (lang, sp.title[lang])
+    print "  resource  = %s" % sp.uri
+    print "  action    = %s" % sp.action
+    if len(message) > 1:
+        print "Further Records"
+        for index, record in enumerate(message):
+            if index == 0: continue
+            record.data = make_printable(record.data)
+            print "  [%d] type = %s" %(index, record.type)
+            print "  [%d] name = %s" %(index, record.name)
+            print "  [%d] data = %s" %(index, record.data)
+
+def print_handover_select(message):
+    print "Connection Handover Select Message"
+    number_suffix = ('st', 'nd', 'rd', 'th')
+    message = HandoverSelectMessage(message)
+    for i, carrier in enumerate(message.carriers):
+        carrier_type = carrier['carrier-type']
+        if carrier_type == "application/vnd.wfa.wsc":
+            carrier_name = "Wi-Fi (Simple Config)"
+        elif carrier_type == "application/vnd.bluetooth.ep.oob":
+            carrier_name = "Bluetooth (Easy Pairing)"
+        else:
+            carrier_name = carrier_type
+        print "  %d%s carrier" % (i+1, number_suffix[min(i,3)]),
+        print "is %s" % carrier_name
+        print "    power    = %s" % carrier['power-state']
+        config_data  = carrier['config-data']
+        if carrier_type == "application/vnd.wfa.wsc":
+            cfg = WiFiConfigData.fromstring(config_data)
+            print "    version  = %d.%d" % cfg.version
+            print "    network  = %s" % cfg.ssid
+            print "    password = %s" % cfg.network_key
+            print "    macaddr  = %s" % cfg.mac_address
+            print "    security = %s / %s" % \
+                (cfg.authentication, cfg.encryption)
+        elif carrier_type == "application/vnd.bluetooth.ep.oob":
+            cfg = BluetoothConfigData.fromstring(config_data)
+            print "    bdaddr   = %s" % cfg.device_address
+            print "    class    = %s" % cfg.class_of_device.encode("hex")
+            print "    sp hash  = %s" % cfg.simple_pairing_hash
+            print "    sp rand  = %s" % cfg.simple_pairing_randomizer
+            print "    longname = %s" % cfg.long_name
+            print "    partname = %s" % cfg.short_name
+        else:
+            print carrier
+
+def print_wifi_token(message):
+    try:
+        data = WiFiPasswordData.fromstring(message[0].data)
+        print "  Wi-Fi Password Token"
+        print "    version  = %d.%d" % data.version
+        print "    PK Hash  = %s" % data.public_key_hash.encode("hex")
+        print "    DevPwdID = %s" % data.device_password_id
+        print "    Password = %s" % data.device_password.encode("hex")
+        for key, val in data.other_attributes:
+            print "    0x%04x   = %s" % (key, val.encode("hex"))
+        return
+    except ValueError:
+        pass
+    try:
+        data = WiFiConfigData.fromstring(message[0].data)
+        print "  Wi-Fi Configuration Token"
+        print "    version  = %d.%d" % data.version
+        print "    network  = %s" % data.ssid
+        print "    password = %s" % data.network_key
+        print "    macaddr  = %s" % data.mac_address
+        print "    security = %s / %s" % \
+            (data.authentication, data.encryption)
+        return
+    except ValueError:
+        pass
+    
+class ReaderClient:
+    def __init__(self, mainloop, reader):
+        self._loop = mainloop
+        self._message = None
+        self._reader = reader
+        
+    def save_ndef(self, ndef_msg_string):
+        print "Received %d Bytes: %s" % (len(ndef_msg_string), ndef_msg_string)
+        if len(ndef_msg_string):
+            self._message = nfc.ndef.Message(str(ndef_msg_string))
+        else:
+            print "Empty message received!"
+    
+    def show_ndef(self): 
+        if self._message.type == "urn:nfc:wkt:Sp":
+            print_smartposter(self._message)
+
+        elif self._message.type == "urn:nfc:wkt:Hs":
+            print_handover_select(self._message)
+
+        elif self._message.type == "application/vnd.wfa.wsc":
+            print_wifi_token(self._message)
+
+        else:
+            print "Unknown Message"
+            for index, record in enumerate(self._message):
+                record.data = make_printable(record.data)
+                print "  [%d] record type = %s" %(index, record.type)
+                print "  [%d] record name = %s" %(index, record.name)
+                print "  [%d] record data = %s" %(index, record.data)
+    
+    def show_tag(self, tag_str):
+        self._tag_info = pickle.loads(tag_str)
+        print "NDEF container present"
+        print "  version   = %s" % self._tag_info['version']
+        print "  writeable = %s" % ("no", "yes")[self._tag_info['writeable']]
+        print "  capacity  = %d byte" % self._tag_info['capacity']
+        print "  data size = %d byte" % self._tag_info['size']
+        if self._message:
+            self.show_ndef()
+        else:
+            print "No message",
+            time.sleep(0.5)
+            if self._message:
+                print "received yet. Waiting..."
+                self.show_ndef()
+            else:
+                print "available."
+        self._loop.quit()
+
+def main():
+    
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+    bus = dbus.SystemBus()
+    object = bus.get_object(BUS_NAME, "/nfcpy/tagreader")
+    loop = gobject.MainLoop()
+    client = ReaderClient(mainloop=loop, reader=object)
+    object.connect_to_signal(signal_name="NDEFMessage", 
+                            handler_function=client.save_ndef, 
+                            dbus_interface='org.nfcpy.TagReader',
+                            byte_arrays=True)
+    object.connect_to_signal(signal_name="TagInfo", 
+                            handler_function=client.show_tag, 
+                            dbus_interface='org.nfcpy.TagReader',
+                            byte_arrays=True)
+    try:
+        loop.run()
+    except KeyboardInterrupt:
+        print "Exiting..."
+        loop.quit()
+
+if __name__ == '__main__':
+    from optparse import OptionParser
+
+    parser = OptionParser()
+    parser.add_option("-q", default=True,
+                      action="store_false", dest="verbose",
+                      help="be quiet, only print errors")
+    parser.add_option("-d", default=False,
+                      action="store_true", dest="debug",
+                      help="print debug messages")
+    parser.add_option("-f", type="string",
+                      action="store", dest="logfile",
+                      help="write log messages to LOGFILE")
+
+    global options
+    options, args = parser.parse_args()
+
+    verbosity = logging.INFO if options.verbose else logging.ERROR
+    verbosity = logging.DEBUG if options.debug else verbosity
+    logging.basicConfig(level=verbosity, format='%(message)s')
+
+    if options.logfile:
+        logfile_format = '%(asctime)s %(levelname)-5s [%(name)s] %(message)s'
+        logfile = logging.FileHandler(options.logfile, "w")
+        logfile.setFormatter(logging.Formatter(logfile_format))
+        logfile.setLevel(logging.DEBUG)
+        logging.getLogger('').addHandler(logfile)
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        pass
+

=== added file 'examples/dbus_examples/tagtool.py'
--- examples/dbus_examples/tagtool.py	1970-01-01 00:00:00 +0000
+++ examples/dbus_examples/tagtool.py	2011-01-04 16:28:41 +0000
@@ -0,0 +1,296 @@
+# -----------------------------------------------------------------------------
+# Copyright 2011 Alexander Knaub <[e-mail]>
+#
+# Licensed under the EUPL, Version 1.1 or - as soon they 
+# will be approved by the European Commission - subsequent
+# versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the
+# Licence.
+# You may obtain a copy of the Licence at:
+#
+# http://ec.europa.eu/idabc/eupl
+#
+# Unless required by applicable law or agreed to in
+# writing, software distributed under the Licence is
+# distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied.
+# See the Licence for the specific language governing
+# permissions and limitations under the Licence.
+# -----------------------------------------------------------------------------
+
+import logging
+log = logging.getLogger()
+
+import os
+import sys
+import time
+import string
+import pickle
+import gobject
+import dbus.mainloop.glib
+
+sys.path.insert(1, os.path.split(sys.path[0])[0])
+import nfc
+import nfc.ndef
+
+BUS_NAME = "org.nfcpy.TagReader"
+
+def make_printable(data):
+    printable = string.digits + string.letters + string.punctuation + ' '
+    return ''.join([c if c in printable else '.' for c in data])
+
+def format_data(data):
+    s = []
+    for i in range(0, len(data), 16):
+        s.append("  %04x: " % i)
+        s[-1] += ' '.join(["%02x" % ord(c) for c in data[i:i+16]]) + ' '
+        s[-1] += (8 + 16*3 - len(s[-1])) * ' '
+        s[-1] += make_printable(data[i:i+16])
+    return '\n'.join(s)
+
+
+class ReaderWriterClient:
+    def __init__(self, mainloop, reader):
+        self._loop = mainloop
+        self._message = None
+        self._reader = reader
+        self._loopmode = False
+        self._binary = False
+        self._copying = False
+        
+        
+    @property
+    def loopmode(self):
+        log.debug("returning loopmode = " + str(self._loopmode))
+        return self._loopmode
+    
+    @loopmode.setter
+    def loopmode(self, value):
+        log.debug("set loopmode to " + str(value))
+        self._loopmode = bool(value)
+        
+        
+    def set_binary(self, value):
+        self._binary = value
+
+        
+    def save_ndef(self, ndef_msg_string):
+        if len(ndef_msg_string):
+            self._message = nfc.ndef.Message(str(ndef_msg_string))
+        else:
+            log.info("Empty message received!")
+            
+    def show_ndef(self): # , ndef_msg_string
+        print format_data(self._message.tostring())
+        print "NDEF records:"
+        for index, record in enumerate(self._message):
+            record.data = make_printable(record.data)
+            print "  [%d] type = %s" %(index, record.type)
+            print "  [%d] name = %s" %(index, record.name)
+            print "  [%d] data = %s" %(index, record.data)
+    
+    def show_tag(self, tag_str):
+        self._tag_info = pickle.loads(tag_str)
+        
+        tt3_card_map = {
+            "\x00\xF0": "FeliCa Lite RC-S965",
+            "\x01\xE0": "FeliCa Plug RC-S801/RC-S802",
+            "\x01\x20": "FeliCa Card RC-S976F [212/424kbps]",
+            "\x03\x01": "FeliCa Card RC-S860 [212kbps, 4KB FEPROM]",
+            }
+        print "  " + tt3_card_map.get(self._tag_info.get('pmm')[0:2], 
+                                      "unknown card type")
+        if self._tag_info.get('capacity', 0):
+            print "NDEF content"
+            print "  version   = %s" % self._tag_info['version']
+            print "  writeable = %s" % ("no", "yes")[self._tag_info['writeable']]
+            print "  capacity  = %d byte" % self._tag_info['capacity']
+            print "  data size = %d byte" % self._tag_info['size']
+        print "NDEF container present"
+        # show content:
+        if self._tag_info['size']:
+            if self._message:
+                self.show_ndef()
+            else:
+                print "No message",
+                time.sleep(0.5)
+                if self._message:
+                    print "received yet. Waiting..."
+                    self.show_ndef()
+                else:
+                    print "could be received."
+            
+        else:
+            print "No message available"
+        if not self.loopmode:
+            self._loop.quit()
+    
+    def copy_tag(self, ndef_msg_string):
+            self._message = nfc.ndef.Message(str(ndef_msg_string))
+            log.info("copied {0} byte <= tag".format(len(ndef_msg_string)))
+            
+            raw_input("Place the destination tag on the reader " 
+                      + "and press ENTER.")
+            msg_string = self._message.tostring()
+            self._reader.WriteNDEF(dbus.ByteArray(msg_string))
+            log.info("copied {0} byte => tag".format(len(msg_string)))
+            if self.loopmode:
+                time.sleep(1)
+            else:
+                self._loop.quit()
+    
+    def dump_tag(self, ndef_msg_string):
+        data = ndef_msg_string
+        if not self._binary:
+            data = data.encode("hex")
+        print data
+        if not self.loopmode:
+            self._loop.quit()
+            
+    def load_tag(self):
+        print "Enter Data"
+        if not self._binary:
+            data = sys.stdin.readlines()
+            data = ''.join([l.strip() for l in data])
+            data = data.decode("hex")
+        else:
+            data = sys.stdin.read()
+        print "You entered " + data
+        self._reader.WriteNDEF(dbus.ByteArray(data))
+        log.info("Data written to the tag")
+        if not options.loopmode:
+            self._loop.quit()
+            
+    def format_tag(self):
+        cont = raw_input("This will delete all data on the tag. " 
+                         + "Continue? Y/N ")
+
+        if cont not in "yY":
+            return
+        # call method on reader object:
+        self._format_running = True
+        while True:
+            success = self._reader.FormatTag()
+                                # include this parameters for async. call:
+                                # reply_handler=self.format_reply_handler,
+                                # error_handler=self.format_error_handler
+            if success:
+                print "Formatting successful"
+            else:
+                print "Formatting failed"
+            if not self.loopmode:
+                print "No loop. exiting"
+                break
+            else:
+                print "go on in 1 sec."
+                time.sleep(1)
+    
+    # This method is needed if formatting method of the reader object is 
+    # called asynchronous (non-blocking)   
+    def format_reply_handler(self, success):
+        if success:
+            log.info("Formatting successful")
+        else:
+            log.info("Formatting failed")
+        self._format_running = False
+        if not self._loopmode:
+            self._loop.quit()
+    
+    # This method is needed if formatting method of the reader object is 
+    # called asynchronous (non-blocking)
+    def format_error_handler(self, error):
+        log.warning("Error occured: " + str(error))
+        self._format_running = False
+        self._loop.quit()
+                
+
+def main():
+    log.debug("starting...")
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+    bus = dbus.SystemBus()
+    object = bus.get_object(BUS_NAME, "/nfcpy/tagreader")
+    loop = gobject.MainLoop()
+    client = ReaderWriterClient(mainloop=loop, reader=object)
+    client.loopmode = options.loopmode
+    log.debug("loopmode set to " + str(client.loopmode))
+    if options.command == "show":
+        # Connect reader's signals to the show methods
+        object.connect_to_signal(signal_name="NDEFMessage", 
+                                 handler_function=client.save_ndef, 
+                                 dbus_interface='org.nfcpy.TagReader',
+                                 byte_arrays=True)
+        object.connect_to_signal(signal_name="TagInfo", 
+                                 handler_function=client.show_tag, 
+                                 dbus_interface='org.nfcpy.TagReader',
+                                 byte_arrays=True)
+        loop.run()
+        
+    elif options.command == "format":
+        # Reader/writer method will be called by client
+        client.format_tag()
+    elif options.command == "copy":
+        object.connect_to_signal(signal_name="NDEFMessage", 
+                                 handler_function=client.copy_tag, 
+                                 dbus_interface='org.nfcpy.TagReader',
+                                 byte_arrays=True)
+        loop.run()
+    elif options.command == "dump":
+        client.set_binary(options.binary)
+        object.connect_to_signal(signal_name="NDEFMessage", 
+                                 handler_function=client.dump_tag, 
+                                 dbus_interface='org.nfcpy.TagReader',
+                                 byte_arrays=True)
+        loop.run()
+    elif options.command == "load":
+        client.set_binary(options.binary)
+        client.load_tag()
+    else:
+        log.error("unknown command '{0}'".format(options.command))
+
+if __name__ == '__main__':
+    from optparse import OptionParser, OptionGroup
+
+    usage = ["Usage: %prog [options] command\n",
+             "Commands:",
+             "  show   - pretty print NDEF data",
+             "  dump   - print NDEF data to stdout",
+             "  load   - load NDEF data from stdin",
+             "  copy   - copy NDEF data between tags",
+             "  format - format NDEF partition on tag"]
+
+    parser = OptionParser('\n'.join(usage), version="%prog 0.1")
+    parser.add_option("-l", default=False,
+                      action="store_true", dest="loopmode",
+                      help="run command in loop mode")
+    parser.add_option("-b", default=False,
+                      action="store_true", dest="binary",
+                      help="use binary format for dump/load")
+    parser.add_option("-q", default=True,
+                      action="store_false", dest="verbose",
+                      help="be quiet, only print errors")
+    parser.add_option("-d", default=False,
+                      action="store_true", dest="debug",
+                      help="print debug messages")
+    parser.add_option("-f", type="string",
+                      action="store", dest="logfile",
+                      help="write log messages to LOGFILE")
+
+    global options
+    options, args = parser.parse_args()
+    if len(args) > 0: options.command = args[0]
+    else: options.command = "print"
+
+    verbosity = logging.INFO if options.verbose else logging.ERROR
+    verbosity = logging.DEBUG if options.debug else verbosity
+    logging.basicConfig(level=verbosity, format='%(message)s')
+
+    if options.logfile:
+        logfile_format = '%(asctime)s %(levelname)-5s [%(name)s] %(message)s'
+        logfile = logging.FileHandler(options.logfile, "w")
+        logfile.setFormatter(logging.Formatter(logfile_format))
+        logfile.setLevel(logging.DEBUG)
+        logging.getLogger('').addHandler(logfile)
+
+    main()
+