Merge lp:~andrefcruz/nfcpy/npp-1.0 into lp:nfcpy

[André Cruz]

I implemented the ability for the NPP server to run in single-threaded mode and be stopped by the return of the process() method.

In my scenario this is useful because I only want to receive a message, process it, and continue the program without the NPP server (the Android API only allows the phone to send 1 message per LLCP link establishment).

If you find this useful then merge...

[lp:~andrefcruz/nfcpy/npp-1.0]

75. By André Cruz on 2011-06-16

Support python 2.6.

[Stephen Tiedemann (stephen-tiedemann)]

Andre, I wouldn't mind to make the NPP server single-threaded/single-connection *onyly*. As implemented in Android, it is always *one* system client that opens *one* connection to send NDEF data, An NPP server should actually never need to handle more than one connection at a time (in practice not even during the same session). And I don't think there will be much evolution of the NPP specification; I rather dare to predict a forthcoming Android release will support the NFC Forum way of getting NDEF across LLCP.

[lp:~andrefcruz/nfcpy/npp-1.0]

76. By André Cruz on 2011-06-23

Make single-threaded the default behavior.

[André Cruz (andrefcruz)]

I agree, I made "single-thread" the default behavior. I didn't remove the multi-threaded code since someone may still find a use for it, if they decide to use the NPP protocol using only nfcpy and not Android devices.

[Stephen Tiedemann (stephen-tiedemann)]

Merged to trunk with a few modifications:
- parameter in __init__ renamed 'threaded'
- set listen socket backlog to 0 for non-threaded operation
- rejected server termination by return value from process()
- added option for example npp server to terminate after receipt of one ndef message

review: Approve

=== modified file 'nfc/npp/server.py'
--- nfc/npp/server.py	2011-06-15 08:40:42 +0000
+++ nfc/npp/server.py	2011-06-23 13:55:11 +0000
@@ -12,10 +12,11 @@
 import nfc.llcp
 
 class NPPServer(Thread):
-    """ Simple NPP server
+    """ Simple NPP server. If single_threaded is True then a new thread will not be spawned.
     """
-    def __init__(self):
+    def __init__(self, single_threaded=True):
         super(NPPServer, self).__init__()
+        self.single_threaded = single_threaded
 
     def run(self):
         socket = nfc.llcp.socket(nfc.llcp.DATA_LINK_CONNECTION)
@@ -27,9 +28,15 @@
             nfc.llcp.listen(socket, backlog=2)
             while True:
                 client_socket = nfc.llcp.accept(socket)
-                client_thread = Thread(target=NPPServer.serve,
+                if self.single_threaded:
+                    log.debug("got client in single_threaded mode")
+                    if NPPServer.serve(client_socket, self):
+                        break
+                else:
+                    log.debug("got client, will spawn thread")
+                    client_thread = Thread(target=NPPServer.serve,
                                        args=[client_socket, self])
-                client_thread.start()
+                    client_thread.start()
         except nfc.llcp.Error as e:
             log.error(str(e))
         finally:
@@ -45,20 +52,20 @@
             if data is None:
                 log.debug("connection closed, no data")
                 return
-            
+
             while nfc.llcp.poll(socket, "recv"):
                 data += nfc.llcp.recv(socket)
 
-            log.debug("got {:d} octets data".format(len(data)))
+            log.debug("got {0:d} octets data".format(len(data)))
             if len(data) < 10:
                 log.debug("npp msg initial fragment too short")
                 return # bail out, this is a bad client
 
             version, num_entries = unpack(">BI", data[:5])
-            log.debug("version {:d}, {:d} entries"
+            log.debug("version {0:d}, {1:d} entries"
                       .format(version, num_entries))
             if (version >> 4) > 1:
-                log.debug("unsupported version {:d}".format(version>>4))
+                log.debug("unsupported version {0:d}".format(version>>4))
                 return
 
             if num_entries != 1:
@@ -67,13 +74,13 @@
 
             remaining = data[5:]
             for i in range(num_entries):
-                log.debug("processing NDEF message #{:d}".format(i+1))
+                log.debug("processing NDEF message #{0:d}".format(i+1))
                 if len(remaining) < 5:
                     log.debug("insufficient data for action code and ndef size")
                     return
 
                 action_code, length = unpack(">BI", remaining[:5])
-                log.debug("action code {:d}, ndef length {:d}"
+                log.debug("action code {0:d}, ndef length {1:d}"
                           .format(action_code, length))
 
                 if action_code != 1:
@@ -87,12 +94,14 @@
 
                 # message complete, now handle the request
                 ndef_message_data = remaining[:length]
-                log.debug("have complete ndef message, {:d} octets"
+                log.debug("have complete ndef message, {0:d} octets"
                           .format(len(ndef_message_data)))
-                npp_server.process(ndef_message_data)
+                if npp_server.process(ndef_message_data) and npp_server.single_threaded:
+                    return True
 
                 # prepare for next
                 remaining = remaining[length:]
+            return
 
         except nfc.llcp.Error as e:
             log.debug("caught exception {0}".format(e))
@@ -105,7 +114,8 @@
     def process(self, ndef_message_data):
         """Processes NDEF messages. This method should be overwritten by a
         subclass of NPPServer to customize it's behavior. The default
-        implementation prints each record.
+        implementation prints each record. If NPP server is single threaded
+        and this method returns True, the server stops processing.
         """
         log.debug("ndef push server process message")
         log.debug(ndef_message_data.encode("hex"))