Merge remote-tracking branch 'origin/master'

config/instruction_images/st-ten-1/DEFAULT.svg

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="1200"
+   height="700"
+   viewBox="0 0 1200 700"
+   version="1.1"
+   id="svg5"
+   xml:space="preserve"
+   inkscape:version="1.2.2 (1:1.2.2+202212051550+b0a8486541)"
+   sodipodi:docname="DEFAULT.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg"><sodipodi:namedview
+     id="namedview7"
+     pagecolor="#505050"
+     bordercolor="#eeeeee"
+     borderopacity="1"
+     inkscape:showpageshadow="0"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#505050"
+     inkscape:document-units="mm"
+     showgrid="false"
+     inkscape:zoom="1.0570734"
+     inkscape:cx="365.15913"
+     inkscape:cy="357.59106"
+     inkscape:window-width="2560"
+     inkscape:window-height="1023"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" /><defs
+     id="defs2" /><g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"><text
+       xml:space="preserve"
+       style="font-style:normal;font-weight:normal;font-size:40px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff7f2a;fill-opacity:1;stroke:#aa4400"
+       x="277.31964"
+       y="373.9111"
+       id="text226"><tspan
+         sodipodi:role="line"
+         id="tspan224"
+         x="277.31964"
+         y="373.9111"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:53.3333px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke:#aa4400;fill:#ff7f2a">DISEGNO NON DISPONIBILE</tspan></text></g></svg>

config/machine_settings/st-ten-1.ini

@@ -14,10 +14,11 @@ remote_api: absent
 tecna_t3: present
 vision_saver: absent
 vision: absent
-screwdriver: absent
+screwdriver: present
-#fixture_id: present
+fixture_id: present
 digital_io: present
 external_flush_blow: absent
+barcode_recipe_selection: present
 
 # VERO PROJECT LOCAL SERVER
 [archive_synchronizer_extra]
@@ -104,9 +105,9 @@ settling_pressure_min_percent: 5
 settling_pressure_max_percent: 5
 test_pressure: 7000
 test_time: 10
-test_pressure_qpos: 10 #Q+ Upper test leak limit
+test_pressure_qpos: 5 #Q+ Upper test leak limit
-test_pressure_qneg: 30 #Q- Lower test leak limit
+test_pressure_qneg: 17 #Q- Lower test leak limit
-test_pressure_tt_qpos: 1 # Q+ Upper test leak limit (tube-tube)
+test_pressure_tt_qpos: 5 # Q+ Upper test leak limit (tube-tube)
 test_pressure_tt_qneg: 5 # Q- Lower test leak limit (tube-tube)
 flush_time: 1
 flush_pressure: 100

src/components/archive_synchronizer.py

@@ -19,6 +19,8 @@ from PyQt5.QtCore import QThread
 from requests.adapters import HTTPAdapter, Retry
 from urllib3.exceptions import InsecureRequestWarning
 
+from lib.helpers.recipe_manager import import_recipes, backup_current_recipes
+
 from .component import Component
 from ui.helpers import get_main_window
 # Suppress insecure request warning
@@ -135,6 +137,9 @@ class ArchiveSynchronizer(Component):
         return True
 
     def parse_response_and_execute(self, response):
+        """
+        Parse the response and execute actions based on the `ACTIONS_TO_DO` received.
+        """
         try:
             data = response.json()
             if not isinstance(data, dict):
@@ -147,11 +152,53 @@ class ArchiveSynchronizer(Component):
                 actions = [actions]
 
             for action in actions:
-                remote_path = action.get("remote_path")
+                action_type = action.get("action")  # Determine which type of action to perform
-                local_path = action.get("local_path")
+
-                self.log.info(f"Executing remote fetch with remote_path: {remote_path} and local_path: {local_path}")
+                if action_type == "import":  # Handle import action
-                result = self.remote_fetch(remote_path=remote_path, local_path=local_path)
+                    remote_path = action.get("remote_path")
-                self.log.info(f"Remote fetch result: {result}")
+                    if not remote_path:
+                        self.log.warning("Import action received without a remote_path.")
+                        continue
+
+                    # Use remote_fetch to download the recipe file from the server
+                    fetch_result = self.remote_fetch(remote_path=remote_path, local_path="tmp")
+                    if 'downloaded_file' in fetch_result:
+                        downloaded_file = fetch_result['downloaded_file']
+
+                        self.log.info(f"Recipe file downloaded successfully to {downloaded_file}.")
+
+                        # Perform the import action
+                        try:
+                            # Backup current recipes before importing
+                            backup_path = backup_current_recipes(
+                                config=self.config,  # Backup configuration object
+                                logger=self.log  # Logger for backup messages
+                            )
+                            self.log.info(f"Backup created successfully at {backup_path}.")
+
+                            # Proceed with importing recipes
+                            import_recipes(
+                                config=self.config,
+                                csv_path=downloaded_file,  # Use the downloaded file path
+                                logger=self.log
+                            )
+                            self.log.info(f"Imported recipes successfully from {downloaded_file}.")
+                        except Exception as e:
+                            self.log.error(f"Failed to import recipes: {str(e)}")
+                            continue
+                    else:
+                        self.log.warning(f"Failed to fetch the recipe file: {fetch_result.get('error')}.")
+
+                elif action_type == "download":  # Handle fetch action
+                    remote_path = action.get("remote_path")
+                    local_path = action.get("local_path", "tmp")  # Use "tmp" as a fallback local path
+                    self.log.info(
+                        f"Executing remote fetch with remote_path: {remote_path} and local_path: {local_path}")
+                    result = self.remote_fetch(remote_path=remote_path, local_path=local_path)
+                    self.log.info(f"Remote fetch result: {result}")
+
+                else:
+                    self.log.warning(f"Unhandled action type: {action_type}")
 
         except json.JSONDecodeError:
             self.log.error("Failed to decode JSON response")
@@ -283,8 +330,10 @@ class ArchiveSynchronizer(Component):
                         self.log_to_db(log_time, log_info_type, log_info)
                         return {"error": "Unexpected HTTP response status", "last_update_info": last_update_info}
 
+                    # Make sure the local path exists
                     os.makedirs(local_path, exist_ok=True)
 
+                    # Construct the correct file path
                     local_file_path = os.path.join(local_path, os.path.basename(remote_path))
                     with open(local_file_path, "wb") as f:
                         f.write(response.content)
@@ -292,6 +341,7 @@ class ArchiveSynchronizer(Component):
                     log_info += f" - File downloaded successfully: {local_file_path}"
                     self.log.info(log_info)
                     self.log_to_db(log_time, log_info_type, log_info)
+
                     return {"downloaded_file": local_file_path, "last_update_info": last_update_info}
 
         except requests.ConnectionError as e:

src/components/rfid_pn532.py

@@ -5,8 +5,8 @@ import platform
 from PyQt5.QtCore import QMutex, Qt, QTimer, pyqtSlot, pyqtSignal
 from .component import Component
 import ndef
-import nfc
+import src.lib.nfc
-from nfc.clf import RemoteTarget
+from src.lib.nfc.clf import RemoteTarget
 
 
 class RFID_PN532(Component):
@@ -26,7 +26,7 @@ class RFID_PN532(Component):
         self._period = 1
 
     def open_device(self):
-        self.clf = nfc.ContactlessFrontend()
+        self.clf = src.lib.nfc.ContactlessFrontend()
         for dev in self.dev_list:
             self.connected = self.clf.open(dev)
             if self.connected:
@@ -52,7 +52,7 @@ class RFID_PN532(Component):
                     else:
                         target = self.clf.sense(RemoteTarget('106A'), RemoteTarget('106B'), RemoteTarget('212F'))
                         if target is not None:
-                            tag = nfc.tag.activate(self.clf, target)
+                            tag = src.lib.nfc.tag.activate(self.clf, target)
                             if tag is not None:
                                 self.log.debug("tag present")
                                 if tag.ndef is not None:

src/lib/__init__.py

@@ -0,0 +1 @@
+

src/lib/helpers/recipe_manager.py

@@ -0,0 +1,405 @@
+import os
+import csv
+import locale
+from datetime import datetime
+import shutil
+from PyQt5.QtWidgets import QFileDialog
+from lib.db import Recipes, db  # Assuming these are part of your project structure
+
+
+def read_steps(row, config, defaults=None, unsupported_steps=None):
+    if defaults is None:
+        defaults = config.get("recipes_defaults", lambda k: None)
+
+    # Configurable fields from the config object
+    barcode_serial_field = config.get("recipe", {}).get("barcode_serial_field", "codice_a_barre").strip()
+    warning_image_field = config.get("recipe", {}).get("warning_image_field", "warning_img").strip()
+    print_template_field = config.get("recipe", {}).get("label_template_field", "modello_etichetta").strip()
+    decsep = locale.localeconv()["decimal_point"]
+
+    # Extract and clean "r nominale" value
+    rcsv = (
+        row.get("r nominale", defaults["r nominale"])
+        .replace(" ", "").replace(",", decsep).replace("Ω", "").replace("?", "")
+    )
+    if rcsv == "":
+        rcsv = "999"  # Default fallback for "r nominale" if empty
+
+    # Helper functions
+    def get_default_value(field, key):
+        value = field.get(key, defaults[key])
+        return value if value != "" else defaults[key]
+
+    def safe_parse(value):
+        try:
+            return int(float(value))
+        except ValueError:
+            return 0  # Default to 0 if parsing fails
+
+    # Define the steps dictionary
+    steps = {
+        "count": {
+            "amount": row.get("dimensione_lotto", defaults["dimensione_lotto"]),
+            "warning_img": row.get(warning_image_field, defaults["warning_img"]),
+            "require_discard_piece": row.get("richiedi_inserimento_scarto", defaults["richiedi_inserimento_scarto"]),
+        },
+        "connector": {
+            "connector": row.get("connettore", defaults["connettore"]),
+        },
+        "barcodes": {
+            "serial": row.get(barcode_serial_field, defaults["codice_a_barre"]),
+            "n_pieces": row.get("n_componenti", defaults["n_componenti"]),
+            "barcode_input_2": row.get("barcode_input_2", "-"),
+            "barcode_input_3": row.get("barcode_input_3", "-"),
+            "barcode_input_4": row.get("barcode_input_4", "-"),
+            "barcode_input_5": row.get("barcode_input_5", "-"),
+        },
+        "resistance": {
+            "scale": locale.atof(row.get("scala_resistenza", defaults["scala_resistenza"])),
+            "expected": locale.atof(rcsv),
+            "tolerance_pos": locale.atof(get_default_value(row, "tolleranza_resistenza_pos")),
+            "tolerance_neg": locale.atof(get_default_value(row, "tolleranza_resistenza_neg")),
+        },
+        "screws": {
+            "quantity": row.get("viti", defaults["viti"]),
+        },
+        "instruction": {},  # Empty placeholder for future extensions
+        "leak_1": {
+            "pre_filling_time": safe_parse(row.get("tempo_pre_riempimento", defaults["tempo_pre_riempimento"])),
+            "pre_filling_pressure": safe_parse(
+                row.get("pressione_pre_riempimento", defaults["pressione_pre_riempimento"])),
+            "filling_time": safe_parse(row.get("tempo_riempimento", defaults["tempo_riempimento"])),
+            "settling_time": safe_parse(get_default_value(row, "tempo_assestamento")),
+            "settling_pressure_min_percent": safe_parse(
+                row.get("percentuale_minima_pressione_assestamento",
+                        defaults["percentuale_minima_pressione_assestamento"])
+            ),
+            "settling_pressure_max_percent": safe_parse(
+                row.get("percentuale_massima_pressione_assestamento",
+                        defaults["percentuale_massima_pressione_assestamento"])
+            ),
+            "test_time": safe_parse(row.get("tempo_di_test", defaults["tempo_di_test"])),
+            "test_pressure_qneg": safe_parse(
+                row.get("pressione_di_test_delta_minimo", defaults["pressione_di_test_delta_minimo"])),
+            "test_pressure": safe_parse(row.get("pressione_di_test", defaults["pressione_di_test"])),
+            "test_pressure_qpos": safe_parse(
+                row.get("pressione_di_test_delta_massimo", defaults["pressione_di_test_delta_massimo"])),
+            "flush_time": safe_parse(row.get("tempo_svuotamento", defaults["tempo_svuotamento"])),
+            "flush_pressure": safe_parse(row.get("pressione_svuotamento", defaults["pressione_svuotamento"])),
+            "chan_sel": safe_parse(row.get("canale_di_prova", defaults["canale_di_prova"])),
+            "ext_flush_time": safe_parse(row.get("tempo_svuotamento_esterno", defaults["tempo_svuotamento_esterno"])),
+            "ext_blow_time": safe_parse(row.get("tempo_soffiaggio_esterno", defaults["tempo_soffiaggio_esterno"])),
+        },
+        "leak_2": {
+            "pre_filling_time": safe_parse(row.get("tempo_pre_riempimento_2", defaults["tempo_pre_riempimento_2"])),
+            "pre_filling_pressure": safe_parse(
+                row.get("pressione_pre_riempimento_2", defaults["pressione_pre_riempimento_2"])),
+            "filling_time": safe_parse(row.get("tempo_riempimento_2", defaults["tempo_riempimento_2"])),
+            "settling_time": safe_parse(row.get("tempo_assestamento_2", defaults["tempo_assestamento_2"])),
+            "settling_pressure_min_percent": safe_parse(
+                row.get("percentuale_minima_pressione_assestamento_2",
+                        defaults["percentuale_minima_pressione_assestamento_2"])
+            ),
+            "settling_pressure_max_percent": safe_parse(
+                row.get("percentuale_massima_pressione_assestamento_2",
+                        defaults["percentuale_massima_pressione_assestamento_2"])
+            ),
+            "test_time": safe_parse(row.get("tempo_di_test_2", defaults["tempo_di_test_2"])),
+            "test_pressure_qneg": safe_parse(
+                row.get("pressione_di_test_delta_minimo_2", defaults["pressione_di_test_delta_minimo_2"])),
+            "test_pressure": safe_parse(row.get("pressione_di_test_2", defaults["pressione_di_test_2"])),
+            "test_pressure_qpos": safe_parse(
+                row.get("pressione_di_test_delta_massimo_2", defaults["pressione_di_test_delta_massimo_2"])),
+            "flush_time": safe_parse(row.get("tempo_svuotamento_2", defaults["tempo_svuotamento_2"])),
+            "flush_pressure": safe_parse(row.get("pressione_svuotamento_2", defaults["pressione_svuotamento_2"])),
+            "chan_sel": safe_parse(row.get("canale_di_prova_2", defaults["canale_di_prova_2"])),
+            "ext_flush_time": safe_parse(row.get("tempo_svuotamento_esterno_2", defaults["tempo_svuotamento_esterno"])),
+            "ext_blow_time": safe_parse(row.get("tempo_soffiaggio_esterno_2", defaults["tempo_soffiaggio_esterno"])),
+        },
+        "vision": {
+            "recipe": row.get("ricetta_visione", defaults["ricetta_visione"]),
+        },
+        "print": {
+            "template": row.get(print_template_field, defaults["modello_etichetta"]),
+            "labeltxt_1": row.get("testo_etich_1", ""),
+            "labeltxt_2": row.get("testo_etich_2", ""),
+            "labeltxt_3": row.get("testo_etich_3", ""),
+            "labeltxt_4": row.get("testo_etich_4", ""),
+            "labeltxt_5": row.get("barcode_input_finelinea", ""),
+            "extra_label": row.get("etichette_supplementari", ""),
+        },
+    }
+
+    # Remove unsupported steps if specified
+    if unsupported_steps:
+        for step in unsupported_steps:
+            steps.pop(step, None)
+
+    return steps
+
+
+
+def import_recipes(config, csv_path=None, defaults=None, unsupported_steps=None, logger=None):
+    """
+    Import recipes from CSV and update or create new ones in the database.
+
+    :param config: Configuration object with recipe settings.
+    :param csv_path: Path to the CSV file (optional). If None, a file dialog will open.
+    :param defaults: Default values to use for missing fields in the CSV.
+    :param unsupported_steps: A list of unsupported step names to exclude.
+    :param logger: Logger object for logging messages (optional).
+    """
+    if defaults is None:
+        defaults = config.get("recipes_defaults", lambda k: None)
+
+    # Open file dialog if csv_path is not provided
+    if csv_path is None:
+        options = QFileDialog.Options()
+        options |= QFileDialog.DontUseNativeDialog
+        csv_path, _ = QFileDialog.getOpenFileName(
+            None,
+            "Import Recipes",
+            "recipes.csv",
+            "CSV files (*.csv);;All Files (*)",
+            options=options,
+        )
+    csv_path = str(csv_path)
+    if not len(csv_path):
+        return
+
+    if logger:
+        logger.info(f"Importing recipes from: {csv_path}.")
+
+    # Get field mappings from the config
+    recipe_name_field = config.get("recipe", {}).get("recipe_name_field", "codice_ricetta").strip()
+    part_number_field = config.get("recipe", {}).get("part_number_field", "part_number").strip()
+    description_field = config.get("recipe", {}).get("description_field", "descrizione").strip()
+    barcode_enable_field = config.get(
+        "recipe", {}
+    ).get("barcode_enable_field", "verifica_codice_a_barre_abilitata").strip()
+
+    with open(csv_path, "r", encoding="utf-8-sig") as file:
+        reader = csv.DictReader(file)
+        count = 0
+
+        for ucrow in reader:
+            # Normalize row keys to lowercase for consistency
+            row = dict((k.lower(), v) for k, v in ucrow.items())
+            recipe_name = row.get(recipe_name_field, defaults["codice_ricetta"])
+            steps_specs = read_steps(row, config, defaults=defaults, unsupported_steps=unsupported_steps)
+
+            # Create or update recipe in the database
+            try:
+                # Try to fetch existing recipe
+                recipe = Recipes.get_by_id(recipe_name)
+                recipe_is_new = False
+            except Recipes.DoesNotExist:
+                # Create a new recipe if it doesn't exist
+                recipe = Recipes(name=recipe_name, part_number="TEMPORARY")
+                recipe_is_new = True
+
+            # Update recipe attributes
+            recipe.client = row.get("cliente", defaults["cliente"])
+            recipe.part_number = row.get(part_number_field, defaults["part_number"])
+            recipe.description = row.get(description_field, defaults["descrizione"])
+
+            # Recipe specifications
+            steps = {}
+            for step_name, step_spec in steps_specs.items():
+                if unsupported_steps is None or step_name not in unsupported_steps:
+                    steps[step_name] = step_spec
+
+            recipe.spec = {
+                "count": len(
+                    row.get("dimensione_lotto_abilitata", defaults["dimensione_lotto_abilitata"])) and "count" not in (
+                                     unsupported_steps or []),
+                "connector": len(row.get("verifica_connettore_abilitata",
+                                         defaults["verifica_connettore_abilitata"])) and "connector" not in (
+                                         unsupported_steps or []),
+                "barcodes": len(row.get(barcode_enable_field,
+                                        defaults["verifica_codice_a_barre_abilitata"])) and "barcodes" not in (
+                                        unsupported_steps or []),
+                "resistance": len(row.get("verifica_resistenza_connettore_abilitata", defaults[
+                    "verifica_resistenza_connettore_abilitata"])) and "resistance" not in (unsupported_steps or []),
+                "screws": len(row.get("avvitatura_abilitata", defaults["avvitatura_abilitata"])) and "screws" not in (
+                            unsupported_steps or []),
+                "instruction": len(
+                    row.get("istruzione_abilitata", defaults["istruzione_abilitata"])) and "instruction" not in (
+                                           unsupported_steps or []),
+                "instruction_extra": len(row.get("istruzione_abilitata_extra", defaults[
+                    "istruzione_abilitata_extra"])) and "instruction_extra" not in (unsupported_steps or []),
+                "leak_1": len(
+                    row.get("prova_tenuta_abilitata", defaults["prova_tenuta_abilitata"])) and "leak_1" not in (
+                                      unsupported_steps or []),
+                "leak_2": len(
+                    row.get("prova_tenuta_abilitata_2", defaults["prova_tenuta_abilitata_2"])) and "leak_2" not in (
+                                      unsupported_steps or []),
+                "vision": len(
+                    row.get("test_visione_abilitato", defaults["test_visione_abilitato"])) and "vision" not in (
+                                      unsupported_steps or []),
+                "print": len(
+                    row.get("stampa_etichetta_abilitata", defaults["stampa_etichetta_abilitata"])) and "print" not in (
+                                     unsupported_steps or []),
+                "steps": steps_specs,
+            }
+
+            if recipe_is_new:
+                recipe.save(force_insert=True)  # Insert new recipe
+            else:
+                recipe.save()  # Update existing recipe
+
+            count += 1  # Increment imported recipe count
+
+        db.commit()  # Commit all changes to the database
+
+        if logger:
+            logger.info(f"Imported {count} recipes.")
+
+
+
+def export_recipes(config, csv_path=None, logger=None):
+    if csv_path is None:
+        options = QFileDialog.Options()
+        options |= QFileDialog.DontUseNativeDialog
+        csv_path, _ = QFileDialog.getSaveFileName(
+            None,
+            "Export Recipes",
+            "recipes.csv",
+            "CSV files (*.csv);;All Files (*)",
+            options=options,
+        )
+    csv_path = str(csv_path)
+    if not len(csv_path):
+        return
+
+    if not csv_path.lower().endswith(".csv"):
+        csv_path += ".csv"
+    os.makedirs(os.path.dirname(csv_path), exist_ok=True)
+
+    recipe_name_field = config.get("recipe", {}).get("recipe_name_field", "codice_ricetta").strip()
+    barcode_enable_field = config.get("recipe", {}).get("barcode_enable_field",
+                                                        "verifica_codice_a_barre_abilitata").strip()
+    barcode_serial_field = config.get("recipe", {}).get("barcode_serial_field", "codice_a_barre").strip()
+    print_template_field = config.get("recipe", {}).get("label_template_field", "modello_etichetta").strip()
+    data = []
+    fieldnames = set()  # Use a set to avoid duplicates
+
+    # Iterate over all recipes in the database
+    for recipe in Recipes.select():
+        steps = recipe.get_steps_map()
+        exportable = {
+            # Base fields
+            recipe_name_field: recipe.name,
+            "cliente": recipe.client,
+            "part_number": recipe.part_number,
+        }
+
+        # Add base fields to the fieldnames
+        fieldnames.update([recipe_name_field, "cliente", "part_number"])
+
+        # Check and add steps conditionally
+        if "connector" in steps:
+            exportable.update({
+                "verifica_connettore_abilitata": "x",
+                "connettore": steps["connector"].spec["connector"]
+            })
+            fieldnames.update(["verifica_connettore_abilitata", "connettore"])
+
+        if "resistance" in steps:
+            exportable.update({
+                "verifica_resistenza_connettore_abilitata": "x",
+                "scala_resistenza": steps["resistance"].spec["scale"],
+                "r nominale": steps["resistance"].spec["expected"],
+                "tolleranza_resistenza_pos": steps["resistance"].spec["tolerance_pos"],
+                "tolleranza_resistenza_neg": steps["resistance"].spec["tolerance_neg"],
+            })
+            fieldnames.update(["verifica_resistenza_connettore_abilitata", "scala_resistenza", "r nominale",
+                               "tolleranza_resistenza_pos", "tolleranza_resistenza_neg"])
+
+        if "barcodes" in steps:
+            exportable.update({
+                barcode_enable_field: "x",
+                barcode_serial_field: steps["barcodes"].spec["serial"]
+            })
+            fieldnames.update([barcode_enable_field, barcode_serial_field])
+
+        if "screws" in steps:
+            exportable.update({
+                "avvitatura_abilitata": "x",
+                "viti": steps["screws"].spec["quantity"]
+            })
+            fieldnames.update(["avvitatura_abilitata", "viti"])
+
+        if "leak_1" in steps:
+            exportable.update({
+                "prova_tenuta_abilitata": "x",
+                "tempo_pre_riempimento": steps["leak_1"].spec["pre_filling_time"],
+                "pressione_pre_riempimento": steps["leak_1"].spec["pre_filling_pressure"],
+                "tempo_di_test": steps["leak_1"].spec["test_time"],
+                "pressione_di_test": steps["leak_1"].spec["test_pressure"],
+            })
+            fieldnames.update(["prova_tenuta_abilitata", "tempo_pre_riempimento", "pressione_pre_riempimento",
+                               "tempo_di_test", "pressione_di_test"])
+
+        if "leak_2" in steps:
+            exportable.update({
+                "prova_tenuta_abilitata_2": "x",
+                "tempo_pre_riempimento_2": steps["leak_2"].spec["pre_filling_time"],
+                "pressione_pre_riempimento_2": steps["leak_2"].spec["pre_filling_pressure"],
+                "tempo_di_test_2": steps["leak_2"].spec["test_time"],
+                "pressione_di_test_2": steps["leak_2"].spec["test_pressure"],
+            })
+            fieldnames.update(["prova_tenuta_abilitata_2", "tempo_pre_riempimento_2", "pressione_pre_riempimento_2",
+                               "tempo_di_test_2", "pressione_di_test_2"])
+
+        if "vision" in steps:
+            exportable.update({
+                "test_visione_abilitato": steps["vision"].spec.get("enabled", ""),
+                "ricetta_visione": steps["vision"].spec["recipe"]
+            })
+            fieldnames.update(["test_visione_abilitato", "ricetta_visione"])
+
+        if "print" in steps:
+            exportable.update({
+                "stampa_etichetta_abilitata": "x",
+                print_template_field: steps["print"].spec["template"],
+            })
+            fieldnames.update(["stampa_etichetta_abilitata", print_template_field])
+
+        # Append the exportable row to the data
+        data.append(exportable)
+
+    # Export data to CSV if there is any data
+    if len(data):
+        if logger:
+            logger.info(f"Exporting recipes to {csv_path}")
+        with open(csv_path, "w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=list(fieldnames))
+            writer.writeheader()
+            writer.writerows(data)
+        if logger:
+            logger.info(f"Exported {len(data)} recipes to {csv_path}.")
+
+
+def backup_current_recipes(config, logger=None):
+    """
+    Back up current recipes to a timestamped CSV file in the predefined backup directory.
+    """
+    # Define the backup directory and file name
+    backup_dir = os.path.join('config', 'csv_import', 'backup_csv')
+    timestamp = datetime.now().strftime("%d%m%y%H%M%S")
+    backup_file = f"backup_{timestamp}.csv"
+    backup_path = os.path.join(backup_dir, backup_file)
+
+    # Ensure the backup directory exists
+    os.makedirs(backup_dir, exist_ok=True)
+
+    # Export current recipes to the backup path
+    export_recipes(config=config, csv_path=backup_path, logger=logger)
+
+    if logger:
+        logger.info(f"Backup created at: {backup_path}")
+
+    return backup_path  # Return the backup path for reference if needed
+
+

src/lib/nfc/__init__.py

@@ -0,0 +1,47 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+from . import clf                                                  # noqa: F401
+from . import tag                                                  # noqa: F401
+from . import llcp                                                 # noqa: F401
+from . import snep                                                 # noqa: F401
+from . import handover                                             # noqa: F401
+from .clf import ContactlessFrontend                               # noqa: F401
+
+import logging
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logging.getLogger(__name__).setLevel(logging.INFO)
+
+# METADATA ####################################################################
+
+__version__ = "1.0.4"
+
+__title__ = "nfcpy"
+__description__ = "Python module for Near Field Communication."
+__uri__ = "https://github.com/nfcpy/nfcpy"
+
+__author__ = "Stephen Tiedemann"
+__email__ = "stephen.tiedemann@gmail.com"
+
+__license__ = "EUPL"
+__copyright__ = "Copyright (c) 2009, 2019 Stephen Tiedemann"
+
+###############################################################################

src/lib/nfc/__main__.py

@@ -0,0 +1,214 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2016 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 nfc
+import nfc.clf.device
+import nfc.clf.transport
+
+import os
+import errno
+import logging
+import platform
+import argparse
+import subprocess
+
+description = """
+
+The nfcpy module implements a near field communication software stack
+for reading and writing NFC Tags or peer-to-peer communication with
+another NFC Device. It requires an NFC radio module connected through
+either USB or serial interface. The nfcpy module is supposed to be
+used within other applications, executing it as a module will try to
+locate contactless devices connected to this machine.
+
+"""
+
+
+def main(args):
+    print("This is the %s version of nfcpy run in Python %s\non %s" %
+          (nfc.__version__, platform.python_version(), platform.platform()))
+    print("I'm now searching your system for contactless devices")
+
+    logging.basicConfig()
+    log_levels = (logging.WARN, logging.INFO, logging.DEBUG, logging.DEBUG-1)
+    log_level = log_levels[min(args.verbose, len(log_levels) - 1)]
+    logging.getLogger('nfc').setLevel(log_level)
+
+    found = 0
+    for vid, pid, bus, dev in nfc.clf.transport.USB.find("usb"):
+        if (vid, pid) in nfc.clf.device.usb_device_map:
+            path = "usb:{0:03d}:{1:03d}".format(bus, dev)
+            try:
+                clf = nfc.ContactlessFrontend(path)
+                print("** found %s" % clf.device)
+                clf.close()
+                found += 1
+            except IOError as error:
+                if error.errno == errno.EACCES:
+                    usb_device_access_denied(bus, dev, vid, pid, path)
+                elif error.errno == errno.EBUSY:
+                    usb_device_found_is_busy(bus, dev, vid, pid, path)
+
+    if args.search_tty:
+        for dev in nfc.clf.transport.TTY.find("tty")[0]:
+            path = "tty:{0}".format(dev[8:])
+            try:
+                clf = nfc.ContactlessFrontend(path)
+                print("** found %s" % clf.device)
+                clf.close()
+                found += 1
+            except IOError as error:
+                if error.errno == errno.EACCES:
+                    print("access denied for device with path %s" % path)
+                elif error.errno == errno.EBUSY:
+                    print("the device with path %s is busy" % path)
+    else:
+        print("I'm not trying serial devices because you haven't told me")
+        print("-- add the option '--search-tty' to have me looking")
+        print("-- but beware that this may break other serial devs")
+
+    if not found:
+        print("Sorry, but I couldn't find any contactless device")
+
+
+def usb_device_access_denied(bus, dev, vid, pid, path):
+    info = "** found usb:{vid:04x}:{pid:04x} at {path} but access is denied"
+    print(info.format(vid=vid, pid=pid, path=path))
+    if platform.system().lower() == "linux":
+        devnode = "/dev/bus/usb/{0:03d}/{1:03d}".format(bus, dev)
+        if not os.access(devnode, os.R_OK | os.W_OK):
+            import pwd
+            import grp
+            usrname = pwd.getpwuid(os.getuid()).pw_name
+            devinfo = os.stat(devnode)
+            dev_usr = pwd.getpwuid(devinfo.st_uid).pw_name
+            dev_grp = grp.getgrgid(devinfo.st_gid).gr_name
+            try:
+                plugdev = grp.getgrnam("plugdev")
+            except KeyError:
+                plugdev = None
+
+            udev_rule = 'SUBSYSTEM==\\"usb\\", ACTION==\\"add\\", ' \
+                        'ATTRS{{idVendor}}==\\"{vid:04x}\\", ' \
+                        'ATTRS{{idProduct}}==\\"{pid:04x}\\", ' \
+                        '{action}'
+            udev_file = "/etc/udev/rules.d/nfcdev.rules"
+
+            print("-- the device is owned by '{dev_usr}' but you are '{user}'"
+                  .format(dev_usr=dev_usr, user=usrname))
+            print("-- also members of the '{dev_grp}' group would be permitted"
+                  .format(dev_grp=dev_grp))
+            print("-- you could use 'sudo' but this is not recommended")
+
+            if plugdev is None:
+                print("-- it's better to adjust the device permissions")
+                action = 'MODE=\\"0666\\"'
+                udev_rule = udev_rule.format(vid=vid, pid=pid, action=action)
+                print("   sudo sh -c 'echo {udev_rule} >> {udev_file}'"
+                      .format(udev_rule=udev_rule, udev_file=udev_file))
+                print("   sudo udevadm control -R # then re-attach device")
+            elif dev_grp != "plugdev":
+                print("-- better assign the device to the 'plugdev' group")
+                action = 'GROUP=\\"plugdev\\"'
+                udev_rule = udev_rule.format(vid=vid, pid=pid, action=action)
+                print("   sudo sh -c 'echo {udev_rule} >> {udev_file}'"
+                      .format(udev_rule=udev_rule, udev_file=udev_file))
+                print("   sudo udevadm control -R # then re-attach device")
+                if usrname not in plugdev.gr_mem:
+                    print("-- and make yourself member of the 'plugdev' group")
+                    print("   sudo adduser {0} plugdev".format(usrname))
+                    print("   su - {0} # or logout once".format(usrname))
+            elif usrname not in plugdev.gr_mem:
+                print("-- you should add yourself to the 'plugdev' group")
+                print("   sudo adduser {0} plugdev".format(usrname))
+                print("   su - {0} # or logout once".format(usrname))
+            else:
+                print("-- but unfortunately I have no better idea than that")
+
+
+def usb_device_found_is_busy(bus, dev, vid, pid, path):
+    info = "** found usb:{vid:04x}:{pid:04x} at {path} but it's already used"
+    print(info.format(vid=vid, pid=pid, path=path))
+    if platform.system().lower() == "linux":
+        sysfs = '/sys/bus/usb/devices/'
+        for entry in os.listdir(sysfs):
+            if not entry.startswith("usb") and ':' not in entry:
+                sysfs_device_entry = sysfs + entry + '/'
+                busnum = open(sysfs_device_entry + 'busnum').read().strip()
+                devnum = open(sysfs_device_entry + 'devnum').read().strip()
+                if int(busnum) == bus and int(devnum) == dev:
+                    break
+        else:
+            print("-- impossible but nothing found in /sys/bus/usb/devices")
+            return
+
+        # We now have the sysfs entry for the device in question. All
+        # supported contactless devices have a single configuration
+        # that will be listed if the device is used by another driver.
+
+        blf = "/etc/modprobe.d/blacklist-nfc.conf"
+        sysfs_config_entry = sysfs_device_entry[:-1] + ":1.0/"
+        print("-- scan sysfs entry at '%s'" % sysfs_config_entry)
+        driver = os.readlink(sysfs_config_entry + "driver").split('/')[-1]
+        print("-- the device is used by the '%s' kernel driver" % driver)
+        if os.access(sysfs_config_entry + "nfc", os.F_OK):
+            print("-- this kernel driver belongs to the linux nfc subsystem")
+            print("-- you can remove it to free the device for this session")
+            print("   sudo modprobe -r %s" % driver)
+            print("-- and blacklist the driver to prevent loading next time")
+            print("   sudo sh -c 'echo blacklist %s >> %s'" % (driver, blf))
+        elif driver == "usbfs":
+            print("-- this indicates a user mode driver with libusb")
+            devnode = "/dev/bus/usb/{0:03d}/{1:03d}".format(bus, dev)
+            print("-- find the process that uses " + devnode)
+            try:
+                subprocess.check_output("which lsof".split())
+            except subprocess.CalledProcessError:
+                print("-- there is no 'lsof' command, can't help further")
+            else:
+                lsof = "lsof -t " + devnode
+                try:
+                    pid = subprocess.check_output(lsof.split()).strip()
+                except subprocess.CalledProcessError:
+                    pid = None
+                if pid is not None:
+                    ps = "ps --no-headers -o cmd -p %s" % pid
+                    cmd = subprocess.check_output(ps.split()).strip()
+                    cwd = os.readlink("/proc/%s/cwd" % pid)
+                    print("-- found that process %s uses the device" % pid)
+                    print("-- process %s is '%s'" % (pid, cmd))
+                    print("-- in directory '%s'" % cwd)
+                else:
+                    print("   ps --no-headers -o cmd -p `sudo %s`" % lsof)
+
+
+parser = argparse.ArgumentParser(
+    prog="python -m nfc", description=description)
+
+parser.add_argument(
+    "--search-tty", action="store_true",
+    help="do also search for serial devices on linux")
+
+parser.add_argument(
+    "--verbose", "-v", action="count", default=0,
+    help="be verbose. Multiple -v options increase the verbosity.")
+
+main(parser.parse_args())

src/lib/nfc/clf/acr122.py

@@ -0,0 +1,242 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2011, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""Device driver for the Arygon ACR122U contactless reader.
+
+The Arygon ACR122U is a PC/SC compliant contactless reader that
+connects via USB and uses the USB CCID profile. It is normally
+intented to be used with a PC/SC stack but this driver interfaces
+directly with the inbuilt PN532 chipset by tunneling commands through
+the PC/SC Escape command. The driver is limited in functionality
+because the embedded microprocessor (that implements the PC/SC stack)
+also operates the PN532; it does not allow all commands to pass as
+desired and reacts on chip responses with its own (legitimate)
+interpretation of state.
+
+==========  =======  ============
+function    support  remarks
+==========  =======  ============
+sense_tta   yes      Type 1 (Topaz) Tags are not supported
+sense_ttb   yes      ATTRIB by firmware voided with S(DESELECT)
+sense_ttf   yes
+sense_dep   yes
+listen_tta  no
+listen_ttb  no
+listen_ttf  no
+listen_dep  no
+==========  =======  ============
+
+"""
+import nfc.clf
+from . import pn532
+
+import os
+import errno
+import struct
+from binascii import hexlify
+
+import logging
+log = logging.getLogger(__name__)
+
+
+def init(transport):
+    device = Device(Chipset(transport))
+    device._vendor_name = transport.manufacturer_name
+    device._device_name = transport.product_name.split()[0]
+    return device
+
+
+class Device(pn532.Device):
+    # Device driver class for the ACR122U.
+
+    def __init__(self, chipset):
+        super(Device, self).__init__(chipset, logger=log)
+
+    def sense_tta(self, target):
+        """Activate the RF field and probe for a Type A Target at 106
+        kbps. Other bitrates are not supported. Type 1 Tags are not
+        supported because the device does not allow to send the
+        correct RID command (even though the PN532 does).
+
+        """
+        return super(Device, self).sense_tta(target)
+
+    def sense_ttb(self, target):
+        """Activate the RF field and probe for a Type B Target.
+
+        The RC-S956 can discover Type B Targets (Type 4B Tag) at 106
+        kbps. For a Type 4B Tag the firmware automatically sends an
+        ATTRIB command that configures the use of DID and 64 byte
+        maximum frame size. The driver reverts this configuration with
+        a DESELECT and WUPB command to return the target prepared for
+        activation (which nfcpy does in the tag activation code).
+
+        """
+        return super(Device, self).sense_ttb(target)
+
+    def sense_ttf(self, target):
+        """Activate the RF field and probe for a Type F Target. Bitrates 212
+        and 424 kpbs are supported.
+
+        """
+        return super(Device, self).sense_ttf(target)
+
+    def sense_dep(self, target):
+        """Search for a DEP Target. Both passive and passive communication
+        mode are supported.
+
+        """
+        return super(Device, self).sense_dep(target)
+
+    def listen_tta(self, target, timeout):
+        """Listen as Type A Target is not supported."""
+        info = "{device} does not support listen as Type A Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_ttb(self, target, timeout):
+        """Listen as Type B Target is not supported."""
+        info = "{device} does not support listen as Type B Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_ttf(self, target, timeout):
+        """Listen as Type F Target is not supported."""
+        info = "{device} does not support listen as Type F Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_dep(self, target, timeout):
+        """Listen as DEP Target is not supported."""
+        info = "{device} does not support listen as DEP Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def turn_on_led_and_buzzer(self):
+        """Buzz and turn red."""
+        self.chipset.set_buzzer_and_led_to_active()
+
+    def turn_off_led_and_buzzer(self):
+        """Back to green."""
+        self.chipset.set_buzzer_and_led_to_default()
+
+
+class Chipset(pn532.Chipset):
+    # Maximum size of a host command frame to the contactless chip.
+    host_command_frame_max_size = 254
+
+    # Supported BrTy (baud rate / modulation type) values for the
+    # InListPassiveTarget command. Corresponds to 106 kbps Type A, 212
+    # kbps Type F, 424 kbps Type F, and 106 kbps Type B. The value for
+    # 106 kbps Innovision Jewel Tag (although supported by PN532) is
+    # removed because the RID command can not be send.
+    in_list_passive_target_brty_range = (0, 1, 2, 3)
+
+    def __init__(self, transport):
+        self.transport = transport
+
+        # read ACR122U firmware version string
+        reader_version = self.ccid_xfr_block(bytearray.fromhex("FF00480000"))
+        if not reader_version.startswith(b"ACR122U"):
+            log.error("failed to retrieve ACR122U version string")
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+        if int(chr(reader_version[7])) < 2:
+            log.error("{0} not supported, need 2.x".format(reader_version[7:]))
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+        log.debug("initialize " + reader_version.decode())
+
+        # set icc power on
+        log.debug("CCID ICC-POWER-ON")
+        frame = bytearray.fromhex("62000000000000000000")
+        transport.write(frame)
+        transport.read(100)
+
+        # disable autodetection
+        log.debug("Set PICC Operating Parameters")
+        self.ccid_xfr_block(bytearray.fromhex("FF00517F00"))
+
+        # switch red/green led off/on
+        log.debug("Configure Buzzer and LED")
+        self.set_buzzer_and_led_to_default()
+
+        super(Chipset, self).__init__(transport, logger=log)
+
+    def close(self):
+        self.ccid_xfr_block(bytearray.fromhex("FF00400C0400000000"))
+        self.transport.close()
+        self.transport = None
+
+    def set_buzzer_and_led_to_default(self):
+        """Turn off buzzer and set LED to default (green only). """
+        self.ccid_xfr_block(bytearray.fromhex("FF00400E0400000000"))
+
+    def set_buzzer_and_led_to_active(self, duration_in_ms=300):
+        """Turn on buzzer and set LED to red only. The timeout here must exceed
+         the total buzzer/flash duration defined in bytes 5-8. """
+        duration_in_tenths_of_second = int(min(duration_in_ms / 100, 255))
+        timeout_in_seconds = (duration_in_tenths_of_second + 1) / 10.0
+        data = "FF00400D04{:02X}000101".format(duration_in_tenths_of_second)
+        self.ccid_xfr_block(bytearray.fromhex(data),
+                            timeout=timeout_in_seconds)
+
+    def send_ack(self):
+        # Send an ACK frame, usually to terminate most recent command.
+        self.ccid_xfr_block(Chipset.ACK)
+
+    def ccid_xfr_block(self, data, timeout=0.1):
+        """Encapsulate host command *data* into an PC/SC Escape command to
+        send to the device and extract the chip response if received
+        within *timeout* seconds.
+
+        """
+        frame = struct.pack("<BI5B", 0x6F, len(data), 0, 0, 0, 0, 0) + data
+        self.transport.write(bytearray(frame))
+        frame = self.transport.read(int(timeout * 1000))
+        if not frame or len(frame) < 10:
+            log.error("insufficient data for decoding ccid response")
+            raise IOError(errno.EIO, os.strerror(errno.EIO))
+        if frame[0] != 0x80:
+            log.error("expected a RDR_to_PC_DataBlock")
+            raise IOError(errno.EIO, os.strerror(errno.EIO))
+        if len(frame) != 10 + struct.unpack("<I", memoryview(frame)[1:5])[0]:
+            log.error("RDR_to_PC_DataBlock length mismatch")
+            raise IOError(errno.EIO, os.strerror(errno.EIO))
+        return frame[10:]
+
+    def command(self, cmd_code, cmd_data, timeout):
+        """Send a host command and return the chip response.
+
+        """
+        log.log(logging.DEBUG-1, "{} {}".format(self.CMD[cmd_code],
+                                                hexlify(cmd_data).decode()))
+
+        frame = bytearray([0xD4, cmd_code]) + bytearray(cmd_data)
+        frame = bytearray([0xFF, 0x00, 0x00, 0x00, len(frame)]) + frame
+
+        frame = self.ccid_xfr_block(frame, timeout)
+        if not frame or len(frame) < 4:
+            log.error("insufficient data for decoding chip response")
+            raise IOError(errno.EIO, os.strerror(errno.EIO))
+        if not (frame[0] == 0xD5 and frame[1] == cmd_code + 1):
+            log.error("received invalid chip response")
+            raise IOError(errno.EIO, os.strerror(errno.EIO))
+        if not (frame[-2] == 0x90 and frame[-1] == 0x00):
+            log.error("received pseudo apdu with error status")
+            raise IOError(errno.EIO, os.strerror(errno.EIO))
+        return frame[2:-2]

src/lib/nfc/clf/arygon.py

@@ -0,0 +1,105 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+#
+# Driver for the Arygon contactless reader with USB serial interface
+#
+from . import pn531
+from . import pn532
+
+import os
+import time
+import errno
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ChipsetA(pn531.Chipset):
+    def write_frame(self, frame):
+        self.transport.write(b"2" + frame)
+
+
+class DeviceA(pn531.Device):
+    def close(self):
+        self.chipset.transport.tty.write(b"0au")  # device reset
+        self.chipset.close()
+        self.chipset = None
+
+
+class ChipsetB(pn532.Chipset):
+    def write_frame(self, frame):
+        self.transport.write(b"2" + frame)
+
+
+class DeviceB(pn532.Device):
+    def close(self):
+        self.chipset.transport.tty.write(b"0au")  # device reset
+        self.chipset.close()
+        self.chipset = None
+
+
+def init(transport):
+    transport.open(transport.port, 115200)
+    transport.tty.write(b"0av")  # read version
+    response = transport.tty.readline()
+    if response.startswith(b"FF00000600V"):
+        log.debug("Arygon Reader AxxB Version %s",
+                  response[11:].strip().decode())
+        transport.tty.timeout = 0.5
+        transport.tty.write(b"0at05")
+        if transport.tty.readline().startswith(b"FF0000"):
+            log.debug("MCU/TAMA communication set to 230400 bps")
+            transport.tty.write(b"0ah05")
+            if transport.tty.readline().startswith(b"FF0000"):
+                log.debug("MCU/HOST communication set to 230400 bps")
+                transport.tty.baudrate = 230400
+                transport.tty.timeout = 0.1
+                time.sleep(0.1)
+                chipset = ChipsetB(transport, logger=log)
+                device = DeviceB(chipset, logger=log)
+                device._vendor_name = "Arygon"
+                device._device_name = "ADRB"
+                return device
+
+    transport.open(transport.port, 9600)
+    transport.tty.write(b"0av")  # read version
+    response = transport.tty.readline()
+    if response.startswith(b"FF00000600V"):
+        log.debug("Arygon Reader AxxA Version %s",
+                  response[11:].strip().decode())
+        transport.tty.timeout = 0.5
+        transport.tty.write(b"0at05")
+        if transport.tty.readline().startswith(b"FF0000"):
+            log.debug("MCU/TAMA communication set to 230400 bps")
+            transport.tty.write(b"0ah05")
+            if transport.tty.readline().startswith(b"FF0000"):
+                log.debug("MCU/HOST communication set to 230400 bps")
+                transport.tty.baudrate = 230400
+                transport.tty.timeout = 0.1
+                time.sleep(0.1)
+                chipset = ChipsetA(transport, logger=log)
+                device = DeviceA(chipset, logger=log)
+                device._vendor_name = "Arygon"
+                device._device_name = "ADRA"
+                return device
+
+    raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))

src/lib/nfc/clf/device.py

@@ -0,0 +1,660 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""All contactless drivers must implement the interface defined in
+:class:`~nfc.clf.device.Device`. Unsupported target discovery or target
+emulation methods raise :exc:`~nfc.clf.UnsupportedTargetError`. The
+interface is used internally by :class:`~nfc.clf.ContactlessFrontend`
+and is not intended as an application programming interface. Device
+driver methods are not thread-safe and do not necessarily check input
+arguments when they are supposed to be valid. The interface may change
+without notice at any time.
+
+"""
+from . import transport
+
+import os
+import sys
+import errno
+import importlib
+
+import logging
+log = logging.getLogger(__name__)
+
+usb_device_map = {
+    (0x054c, 0x0193): "pn531",   # PN531 (Sony VID/PID)
+    (0x04cc, 0x0531): "pn531",   # PN531 (Philips VID/PID), SCM SCL3710
+    (0x04cc, 0x2533): "pn533",   # NXP PN533 demo board
+    (0x04e6, 0x5591): "pn533",   # SCM SCL3711
+    (0x04e6, 0x5593): "pn533",   # SCM SCL3712
+    (0x054c, 0x02e1): "rcs956",  # Sony RC-S330/360/370
+    (0x054c, 0x06c1): "rcs380",  # Sony RC-S380
+    (0x054c, 0x06c3): "rcs380",  # Sony RC-S380
+    (0x072f, 0x2200): "acr122",  # ACS ACR122U
+}
+
+tty_driver_list = ["arygon", "pn532"]
+
+
+def connect(path):
+    """Connect to a local device identified by *path* and load the
+    appropriate device driver. The *path* argument is documented at
+    :meth:`nfc.clf.ContactlessFrontend.open`. The return value is
+    either a :class:`Device` instance or :const:`None`. Note that not
+    all drivers can be autodetected, specifically for serial devices
+    *path* must usually also specify the driver.
+
+    """
+    assert isinstance(path, str) and len(path) > 0
+
+    found = transport.USB.find(path)
+    if found is not None:
+        for vid, pid, bus, dev in found:
+            module = usb_device_map.get((vid, pid))
+            if module is None:
+                continue
+
+            log.debug("loading {mod} driver for usb:{vid:04x}:{pid:04x}"
+                      .format(mod=module, vid=vid, pid=pid))
+
+            if sys.platform.startswith("linux"):
+                devnode = "/dev/bus/usb/%03d/%03d" % (int(bus), int(dev))
+                if not os.access(devnode, os.R_OK | os.W_OK):
+                    log.debug("access denied to " + devnode)
+                    if len(path.split(':')) < 3:
+                        continue
+                    else:
+                        raise IOError(errno.EACCES, os.strerror(errno.EACCES))
+
+            driver = importlib.import_module("nfc.clf." + module)
+            try:
+                device = driver.init(transport.USB(bus, dev))
+            except IOError as error:
+                log.debug(error)
+                if len(path.split(':')) < 3:
+                    continue
+                else:
+                    raise error
+
+            device._path = "usb:{0:03}:{1:03}".format(int(bus), int(dev))
+            return device
+
+    found = transport.TTY.find(path)
+    if found is not None:
+        devices = found[0]
+        drivers = [found[1]] if found[1] else tty_driver_list
+        globbed = found[2] or drivers is tty_driver_list
+        for drv in drivers:
+            for dev in devices:
+                log.debug("trying {0} on {1}".format(drv, dev))
+                driver = importlib.import_module("src.lib.nfc.clf." + drv)
+                tty = None
+                try:
+                    tty = transport.TTY(dev)
+                    device = driver.init(tty)
+                    device._path = dev
+                    return device
+                except IOError as error:
+                    log.debug(error)
+                    if tty is not None:
+                        tty.close()
+                    if not globbed:
+                        raise
+
+    if path.startswith("udp"):
+        path = path.split(':')
+        host = str(path[1]) if len(path) > 1 and path[1] else 'localhost'
+        port = int(path[2]) if len(path) > 2 and path[2] else 54321
+        driver = importlib.import_module("nfc.clf.udp")
+        device = driver.init(host, port)
+        device._path = "udp:{0}:{1}".format(host, port)
+        return device
+
+
+class Device(object):
+    """All device drivers inherit from the :class:`Device` class and must
+    implement it's methods.
+
+    """
+    def __init__(self, *args, **kwargs):
+        fname = "__init__"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def __str__(self):
+        strings = (self.vendor_name, self.product_name, self.chipset_name)
+        return ' '.join(filter(bool, strings)) + " at " + self.path
+
+    @property
+    def vendor_name(self):
+        """The device vendor name. An empty string if the vendor name could
+        not be determined.
+
+        """
+        return self._vendor_name if hasattr(self, "_vendor_name") else ''
+
+    @property
+    def product_name(self):
+        """The device product name. An empty string if the product name could
+        not be determined.
+
+        """
+        return self._device_name if hasattr(self, "_device_name") else ''
+
+    @property
+    def chipset_name(self):
+        """The name of the chipset embedded in the device."""
+        return self._chipset_name
+
+    @property
+    def path(self):
+        return self._path
+
+    def close(self):
+        fname = "close"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def mute(self):
+        """Mutes all existing communication, most notably the device will no
+        longer generate a 13.56 MHz carrier signal when operating as
+        Initiator.
+
+        """
+        fname = "mute"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def sense_tta(self, target):
+        """Discover a Type A Target.
+
+        Activates the 13.56 MHz carrier signal and sends a SENS_REQ
+        command at the bitrate set by **target.brty**. If a response
+        is received, sends an RID_CMD for a Type 1 Tag or SDD_REQ and
+        SEL_REQ for a Type 2/4 Tag and returns the responses.
+
+        Arguments:
+
+          target (nfc.clf.RemoteTarget): Supplies bitrate and optional
+            command data for the target discovery. The only sensible
+            command to set is **sel_req** populated with a UID to find
+            only that specific target.
+
+        Returns:
+
+          nfc.clf.RemoteTarget: Response data received from a remote
+            target if found. This includes at least **sens_res** and
+            either **rid_res** (for a Type 1 Tag) or **sdd_res** and
+            **sel_res** (for a Type 2/4 Tag).
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            or the *target* argument requested an unsupported bitrate
+            (or has a wrong technology type identifier).
+
+        """
+        fname = "sense_tta"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def sense_ttb(self, target):
+        """Discover a Type B Target.
+
+        Activates the 13.56 MHz carrier signal and sends a SENSB_REQ
+        command at the bitrate set by **target.brty**. If a SENSB_RES
+        is received, returns a target object with the **sensb_res**
+        attribute.
+
+        Note that the firmware of some devices (least all those based
+        on PN53x) automatically sends an ATTRIB command with varying
+        but always unfortunate communication settings. The drivers
+        correct that situation by sending S(DESELECT) and WUPB before
+        return.
+
+        Arguments:
+
+          target (nfc.clf.RemoteTarget): Supplies bitrate and the
+            optional **sensb_req** for target discovery. Most drivers
+            do no not allow a fully customized SENSB_REQ, the only
+            parameter that can always be changed is the AFI byte,
+            others may be ignored.
+
+        Returns:
+
+          nfc.clf.RemoteTarget: Response data received from a remote
+            target if found. The only response data attribute is
+            **sensb_res**.
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            or the *target* argument requested an unsupported bitrate
+            (or has a wrong technology type identifier).
+
+        """
+        fname = "sense_ttb"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def sense_ttf(self, target):
+        """Discover a Type F Target.
+
+        Activates the 13.56 MHz carrier signal and sends a SENSF_REQ
+        command at the bitrate set by **target.brty**. If a SENSF_RES
+        is received, returns a target object with the **sensf_res**
+        attribute.
+
+        Arguments:
+
+          target (nfc.clf.RemoteTarget): Supplies bitrate and the
+            optional **sensf_req** for target discovery. The default
+            SENSF_REQ invites all targets to respond and requests the
+            system code information bytes.
+
+        Returns:
+
+          nfc.clf.RemoteTarget: Response data received from a remote
+            target if found. The only response data attribute is
+            **sensf_res**.
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            or the *target* argument requested an unsupported bitrate
+            (or has a wrong technology type identifier).
+
+        """
+        fname = "sense_ttf"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def sense_dep(self, target):
+        """Discover a NFC-DEP Target in active communication mode.
+
+        Activates the 13.56 MHz carrier signal and sends an ATR_REQ
+        command at the bitrate set by **target.brty**. If an ATR_RES
+        is received, returns a target object with the **atr_res**
+        attribute.
+
+        Note that some drivers (like pn531) may modify the transport
+        data bytes length reduction value in ATR_REQ and ATR_RES due
+        to hardware limitations.
+
+        Arguments:
+
+          target (nfc.clf.RemoteTarget): Supplies bitrate and the
+            mandatory **atr_req** for target discovery. The bitrate
+            may be one of '106A', '212F', or '424F'.
+
+        Returns:
+
+          nfc.clf.RemoteTarget: Response data received from a remote
+            target if found. The only response data attribute is
+            **atr_res**. The actually sent and potentially modified
+            ATR_REQ is also included as **atr_req** attribute.
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            or the *target* argument requested an unsupported bitrate
+            (or has a wrong technology type identifier).
+
+        """
+        fname = "sense_dep"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def listen_tta(self, target, timeout):
+        """Listen as Type A Target.
+
+        Waits to receive a SENS_REQ command at the bitrate set by
+        **target.brty** and sends the **target.sens_res**
+        response. Depending on the SENS_RES bytes, the Initiator then
+        sends an RID_CMD (SENS_RES coded for a Type 1 Tag) or SDD_REQ
+        and SEL_REQ (SENS_RES coded for a Type 2/4 Tag). Responses are
+        then generated from the **rid_res** or **sdd_res** and
+        **sel_res** attributes in *target*.
+
+        Note that none of the currently supported hardware can
+        actually receive an RID_CMD, thus Type 1 Tag emulation is
+        impossible.
+
+        Arguments:
+
+          target (nfc.clf.LocalTarget): Supplies bitrate and mandatory
+            response data to reply when being discovered.
+
+          timeout (float): The maximum number of seconds to wait for a
+            discovery command.
+
+        Returns:
+
+          nfc.clf.LocalTarget: Command data received from the remote
+            Initiator if being discovered and to the extent supported
+            by the device. The first command received after discovery
+            is returned as one of the **tt1_cmd**, **tt2_cmd** or
+            **tt4_cmd** attribute (note that unset attributes are
+            always None).
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            or the *target* argument requested an unsupported bitrate
+            (or has a wrong technology type identifier).
+
+          ~exceptions.ValueError: A required target response attribute
+            is not present or does not supply the number of bytes
+            expected.
+
+        """
+        fname = "listen_tta"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def listen_ttb(self, target, timeout):
+        """Listen as Type A Target.
+
+        Waits to receive a SENSB_REQ command at the bitrate set by
+        **target.brty** and sends the **target.sensb_res**
+        response.
+
+        Note that none of the currently supported hardware can
+        actually listen as Type B target.
+
+        Arguments:
+
+          target (nfc.clf.LocalTarget): Supplies bitrate and mandatory
+            response data to reply when being discovered.
+
+          timeout (float): The maximum number of seconds to wait for a
+            discovery command.
+
+        Returns:
+
+          nfc.clf.LocalTarget: Command data received from the remote
+            Initiator if being discovered and to the extent supported
+            by the device. The first command received after discovery
+            is returned as **tt4_cmd** attribute.
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            or the *target* argument requested an unsupported bitrate
+            (or has a wrong technology type identifier).
+
+          ~exceptions.ValueError: A required target response attribute
+            is not present or does not supply the number of bytes
+            expected.
+
+        """
+        fname = "listen_ttb"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def listen_ttf(self, target, timeout):
+        """Listen as Type A Target.
+
+        Waits to receive a SENSF_REQ command at the bitrate set by
+        **target.brty** and sends the **target.sensf_res**
+        response. Then waits for a first command that is not a
+        SENSF_REQ and returns this as the **tt3_cmd** attribute.
+
+        Arguments:
+
+          target (nfc.clf.LocalTarget): Supplies bitrate and mandatory
+            response data to reply when being discovered.
+
+          timeout (float): The maximum number of seconds to wait for a
+            discovery command.
+
+        Returns:
+
+          nfc.clf.LocalTarget: Command data received from the remote
+            Initiator if being discovered and to the extent supported
+            by the device. The first command received after discovery
+            is returned as **tt3_cmd** attribute.
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            or the *target* argument requested an unsupported bitrate
+            (or has a wrong technology type identifier).
+
+          ~exceptions.ValueError: A required target response attribute
+            is not present or does not supply the number of bytes
+            expected.
+
+        """
+        fname = "listen_ttf"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def listen_dep(self, target, timeout):
+        """Listen as NFC-DEP Target.
+
+        Waits to receive an ATR_REQ (if the local device supports
+        active communication mode) or a Type A or F Target activation
+        followed by an ATR_REQ in passive communication mode. The
+        ATR_REQ is replied with **target.atr_res**. The first DEP_REQ
+        command is returned as the **dep_req** attribute along with
+        **atr_req** and **atr_res**. The **psl_req** and **psl_res**
+        attributes are returned when the has Initiator performed a
+        parameter selection. The **sens_res** or **sensf_res**
+        attributes are returned when activation was in passive
+        communication mode.
+
+        Arguments:
+
+          target (nfc.clf.LocalTarget): Supplies mandatory response
+            data to reply when being discovered. All of **sens_res**,
+            **sdd_res**, **sel_res**, **sensf_res**, and **atr_res**
+            must be provided. The bitrate does not need to be set, an
+            NFC-DEP Target always accepts discovery at '106A', '212F
+            and '424F'.
+
+          timeout (float): The maximum number of seconds to wait for a
+            discovery command.
+
+        Returns:
+
+          nfc.clf.LocalTarget: Command data received from the remote
+            Initiator if being discovered and to the extent supported
+            by the device. The first command received after discovery
+            is returned as **dep_req** attribute.
+
+        Raises:
+
+          nfc.clf.UnsupportedTargetError: The method is not supported
+            by the local hardware.
+
+          ~exceptions.ValueError: A required target response attribute
+            is not present or does not supply the number of bytes
+            expected.
+
+        """
+        fname = "listen_dep"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def send_cmd_recv_rsp(self, target, data, timeout):
+        """Exchange data with a remote Target
+
+        Sends command *data* to the remote *target* discovered in the
+        most recent call to one of the sense_xxx() methods. Note that
+        *target* becomes invalid with any call to mute(), sense_xxx()
+        or listen_xxx()
+
+        Arguments:
+
+          target (nfc.clf.RemoteTarget): The target returned by the
+            last successful call of a sense_xxx() method.
+
+          data (bytearray): The binary data to send to the remote
+            device.
+
+          timeout (float): The maximum number of seconds to wait for
+            response data from the remote device.
+
+        Returns:
+
+          bytearray: Response data received from the remote device.
+
+        Raises:
+
+          nfc.clf.CommunicationError: When no data was received.
+
+        """
+        fname = "send_cmd_recv_rsp"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def send_rsp_recv_cmd(self, target, data, timeout=None):
+        """Exchange data with a remote Initiator
+
+        Sends response *data* as the local *target* being discovered
+        in the most recent call to one of the listen_xxx() methods.
+        Note that *target* becomes invalid with any call to mute(),
+        sense_xxx() or listen_xxx()
+
+        Arguments:
+
+          target (nfc.clf.LocalTarget): The target returned by the
+            last successful call of a listen_xxx() method.
+
+          data (bytearray): The binary data to send to the remote
+            device.
+
+          timeout (float): The maximum number of seconds to wait for
+            command data from the remote device.
+
+        Returns:
+
+          bytearray: Command data received from the remote device.
+
+        Raises:
+
+          nfc.clf.CommunicationError: When no data was received.
+
+        """
+        fname = "send_rsp_recv_cmd"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def get_max_send_data_size(self, target):
+        """Returns the maximum number of data bytes for sending.
+
+        The maximum number of data bytes acceptable for sending with
+        either :meth:`send_cmd_recv_rsp` or :meth:`send_rsp_recv_cmd`.
+        The value reflects the local device capabilities for sending
+        in the mode determined by *target*. It does not relate to any
+        protocol capabilities and negotiations.
+
+        Arguments:
+
+          target (nfc.clf.Target): The current local or remote
+            communication target.
+
+        Returns:
+
+          int: Maximum number of data bytes supported for sending.
+
+        """
+        fname = "get_max_send_data_size"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def get_max_recv_data_size(self, target):
+        """Returns the maximum number of data bytes for receiving.
+
+        The maximum number of data bytes acceptable for receiving with
+        either :meth:`send_cmd_recv_rsp` or :meth:`send_rsp_recv_cmd`.
+        The value reflects the local device capabilities for receiving
+        in the mode determined by *target*. It does not relate to any
+        protocol capabilities and negotiations.
+
+        Arguments:
+
+          target (nfc.clf.Target): The current local or remote
+            communication target.
+
+        Returns:
+
+          int: Maximum number of data bytes supported for receiving.
+
+        """
+        fname = "get_max_recv_data_size"
+        cname = self.__class__.__module__ + '.' + self.__class__.__name__
+        raise NotImplementedError("%s.%s() is required" % (cname, fname))
+
+    def turn_on_led_and_buzzer(self):
+        """If a device has an LED and/or a buzzer, this method can be
+        implemented to turn those indicators to the ON state.
+
+        """
+        pass
+
+    def turn_off_led_and_buzzer(self):
+        """If a device has an LED and/or a buzzer, this method can be
+        implemented to turn those indicators to the OFF state.
+
+        """
+        pass
+
+    @staticmethod
+    def add_crc_a(data):
+        # Calculate CRC-A for bytearray *data* and return *data*
+        # extended with the two CRC bytes.
+        crc = calculate_crc(data, len(data), 0x6363)
+        return data + bytearray([crc & 0xff, crc >> 8])
+
+    @staticmethod
+    def check_crc_a(data):
+        # Calculate CRC-A for the leading *len(data)-2* bytes of
+        # bytearray *data* and return whether the result matches the
+        # trailing 2 bytes of *data*.
+        crc = calculate_crc(data, len(data)-2, 0x6363)
+        return (data[-2], data[-1]) == (crc & 0xff, crc >> 8)
+
+    @staticmethod
+    def add_crc_b(data):
+        # Calculate CRC-B for bytearray *data* and return *data*
+        # extended with the two CRC bytes.
+        crc = ~calculate_crc(data, len(data), 0xFFFF) & 0xFFFF
+        return data + bytearray([crc & 0xff, crc >> 8])
+
+    @staticmethod
+    def check_crc_b(data):
+        # Calculate CRC-B for the leading *len(data)-2* bytes of
+        # bytearray *data* and return whether the result matches the
+        # trailing 2 bytes of *data*.
+        crc = ~calculate_crc(data, len(data)-2, 0xFFFF) & 0xFFFF
+        return (data[-2], data[-1]) == (crc & 0xff, crc >> 8)
+
+
+def calculate_crc(data, size, reg):
+    for octet in data[:size]:
+        for pos in range(8):
+            bit = (reg ^ ((octet >> pos) & 1)) & 1
+            reg = reg >> 1
+            if bit:
+                reg = reg ^ 0x8408
+    return reg

src/lib/nfc/clf/pn531.py

@@ -0,0 +1,316 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""Driver module for contactless devices based on the NXP PN531
+chipset. This was once a (sort of) joint development between Philips
+and Sony to supply hardware capable of running the ISO/IEC 18092 Data
+Exchange Protocol. The chip has selectable UART, I2C, SPI, or USB host
+interfaces, For USB the vendor and product ID can be switched by a
+hardware pin to either Philips or Sony.
+
+The internal chipset architecture comprises a small 8-bit MCU and a
+Contactless Interface Unit CIU that is basically a PN511. The CIU
+implements the analog and digital part of communication (modulation
+and framing) while the MCU handles the protocol parts and host
+communication. The PN511 and hence the PN531 does not support Type B
+Technology and can not handle the specific Jewel/Topaz (Type 1 Tag)
+communication. Compared to PN532/PN533 the host frame structure does
+not allow maximum size ISO/IEC 18092 packets to be transferred. The
+driver handles this restriction by modifying the initialization
+commands (ATR, PSL) when needed.
+
+==========  =======  ============
+function    support  remarks
+==========  =======  ============
+sense_tta   yes      Type 1 Tag is not supported
+sense_ttb   no
+sense_ttf   yes
+sense_dep   yes      Reduced transport data byte length (max 192)
+listen_tta  yes
+listen_ttb  no
+listen_ttf  yes      Maximimum frame size is 64 byte
+listen_dep  yes
+==========  =======  ============
+
+"""
+import nfc.clf
+from . import pn53x
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Chipset(pn53x.Chipset):
+    CMD = {
+        # Miscellaneous
+        0x00: "Diagnose",
+        0x02: "GetFirmwareVersion",
+        0x04: "GetGeneralStatus",
+        0x06: "ReadRegister",
+        0x08: "WriteRegister",
+        0x0C: "ReadGPIO",
+        0x0E: "WriteGPIO",
+        0x10: "SetSerialBaudrate",
+        0x12: "SetTAMAParameters",
+        0x14: "SAMConfiguration",
+        0x16: "PowerDown",
+        # RF communication
+        0x32: "RFConfiguration",
+        0x58: "RFRegulationTest",
+        # Initiator
+        0x56: "InJumpForDEP",
+        0x46: "InJumpForPSL",
+        0x4A: "InListPassiveTarget",
+        0x50: "InATR",
+        0x4E: "InPSL",
+        0x40: "InDataExchange",
+        0x42: "InCommunicateThru",
+        0x44: "InDeselect",
+        0x52: "InRelease",
+        0x54: "InSelect",
+        # Target
+        0x8C: "TgInitTAMATarget",
+        0x92: "TgSetGeneralBytes",
+        0x86: "TgGetDEPData",
+        0x8E: "TgSetDEPData",
+        0x94: "TgSetMetaDEPData",
+        0x88: "TgGetInitiatorCommand",
+        0x90: "TgResponseToInitiator",
+        0x8A: "TgGetTargetStatus",
+    }
+    ERR = {
+        0x01: "Time out, the Target has not answered",
+        0x02: "Checksum error during RF communication",
+        0x03: "Parity error during RF communication",
+        0x04: "Erroneous bit count in anticollision",
+        0x05: "Framing error during Mifare operation",
+        0x06: "Abnormal bit collision in 106 kbps anticollision",
+        0x07: "Insufficient communication buffer size",
+        0x09: "RF buffer overflow detected by CIU",
+        0x0a: "RF field not activated in time by active mode peer",
+        0x0b: "Protocol error during RF communication",
+        0x0d: "Overheated - antenna drivers deactivated",
+        0x0e: "Internal buffer overflow",
+        0x10: "Invalid command parameter",
+        0x12: "Unsupported command from Initiator",
+        0x13: "Format error during RF communication",
+        0x14: "Mifare authentication error",
+        0x23: "ISO/IEC14443-3 UID check byte is wrong",
+        0x25: "Command invalid in current DEP state",
+        0x26: "Operation not allowed in this configuration",
+        0x27: "Command is not acceptable in the current context",
+        0x7f: "Invalid command syntax - received error frame",
+        0xff: "Insufficient data received from executing chip command",
+    }
+
+    host_command_frame_max_size = 254
+    """Maximum host command frame size."""
+
+    in_list_passive_target_max_target = 2
+    """Maximum number of targets for the InListPassiveTarget command."""
+
+    in_list_passive_target_brty_range = (0, 1, 2)
+    """Possible values for the brty parameter to InListPassiveTarget."""
+
+    def _read_register(self, data):
+        return self.command(0x06, data, timeout=0.25)
+
+    def _write_register(self, data):
+        self.command(0x08, data, timeout=0.25)
+
+    sam_configuration_modes = ("normal", "virtual", "wired", "dual")
+    """Possible SAM configuration modes."""
+
+    def sam_configuration(self, mode, timeout=0):
+        """Send the SAMConfiguration command to configure the Security Access
+        Module. The *mode* argument must be one of the string values
+        in :data:`sam_configuration_modes`. The *timeout* argument is
+        only relevant for the virtual card configuration mode.
+
+        """
+        mode = self.sam_configuration_modes.index(mode) + 1
+        self.command(0x14, bytearray([mode, timeout]), timeout=0.1)
+
+    power_down_wakeup_sources = ("INT0", "INT1", "USB", "RF", "HSU", "SPI")
+    """Possible wake up sources for the :meth:`power_down` method."""
+
+    def power_down(self, wakeup_enable):
+        """Send the PowerDown command to put the PN531 (including the
+        contactless analog front end) into power down mode in order to
+        save power consumption. The *wakeup_enable* argument must be a
+        list of wake up sources with values from the
+        :data:`power_down_wakeup_sources`.
+
+        """
+        wakeup_set = 0
+        for i, src in enumerate(self.power_down_wakeup_sources):
+            if src in wakeup_enable:
+                wakeup_set |= 1 << i
+        data = self.command(0x16, bytearray([wakeup_set]), timeout=0.1)
+        if data[0] != 0:
+            self.chipset_error(data)
+
+    def tg_init_tama_target(self, mode, mifare_params, felica_params,
+                            nfcid3t, gt, timeout):
+        """Send the TgInitTAMATarget command."""
+        assert type(mode) is int and mode & 0b11111100 == 0
+        assert len(mifare_params) == 6
+        assert len(felica_params) == 18
+        assert len(nfcid3t) == 10
+
+        data = bytearray([mode]) + mifare_params + felica_params + nfcid3t + gt
+        return self.command(0x8c, data, timeout)
+
+
+class Device(pn53x.Device):
+    # Device driver for PN531 based contactless frontends.
+
+    def __init__(self, chipset, logger):
+        assert isinstance(chipset, Chipset)
+        super(Device, self).__init__(chipset, logger)
+
+        ver, rev = self.chipset.get_firmware_version()
+        self._chipset_name = "PN531v{0}.{1}".format(ver, rev)
+        self.log.debug("chipset is a {0}".format(self._chipset_name))
+
+        self.chipset.sam_configuration("normal")
+        self.chipset.set_parameters(0b00000000)
+        self.chipset.rf_configuration(0x02, b"\x00\x0B\x0A")
+        self.chipset.rf_configuration(0x04, b"\x00")
+        self.chipset.rf_configuration(0x05, b"\x01\x00\x01")
+        self.mute()
+
+    def close(self):
+        self.mute()
+        super(Device, self).close()
+
+    def sense_tta(self, target):
+        """Activate the RF field and probe for a Type A Target.
+
+        The PN531 can discover some Type A Targets (Type 2 Tag and
+        Type 4A Tag) at 106 kbps. Type 1 Tags (Jewel/Topaz) are
+        completely unsupported. Because the firmware does not evaluate
+        the SENS_RES before sending SDD_REQ, it may be that a warning
+        message about missing Type 1 Tag support is logged even if a
+        Type 2 or 4A Tag was present. This typically happens when the
+        SDD_RES or SEL_RES are lost due to communication errors
+        (normally when the tag is moved away).
+
+        """
+        target = super(Device, self).sense_tta(target)
+        if target and target.sdd_res and len(target.sdd_res) > 4:
+            # Remove the cascade tag(s) from SDD_RES, only the PN531
+            # has them included and we've set the policy that cascade
+            # tags are not part of the sel_req/sdd_res parameters.
+            if len(target.sdd_res) == 8:
+                target.sdd_res = target.sdd_res[1:]
+            elif len(target.sdd_res) == 12:
+                target.sdd_res = target.sdd_res[1:4] + target.sdd_res[5:]
+            # Also the SENS_RES bytes are reversed compared to PN532/533
+            target.sens_res = bytearray(reversed(target.sens_res))
+        return target
+
+    def sense_ttb(self, target):
+        """Sense for a Type B Target is not supported."""
+        info = "{device} does not support sense for Type B Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def sense_ttf(self, target):
+        """Activate the RF field and probe for a Type F Target.
+
+        """
+        return super(Device, self).sense_ttf(target)
+
+    def sense_dep(self, target):
+        """Search for a DEP Target in active communication mode.
+
+        Because the PN531 does not implement the extended frame syntax
+        for host controller communication, it can not support the
+        maximum payload size of 254 byte. The driver handles this by
+        modifying the length-reduction values in atr_req and atr_res.
+
+        """
+        if target.atr_req[15] & 0x30 == 0x30:
+            self.log.warning("must reduce the max payload size in atr_req")
+            target.atr_req[15] = (target.atr_req[15] & 0xCF) | 0x20
+
+        target = super(Device, self).sense_dep(target)
+        if target is None:
+            return
+
+        if target.atr_res[16] & 0x30 == 0x30:
+            self.log.warning("must reduce the max payload size in atr_res")
+            atr_res = bytearray(target.atr_res)
+            atr_res[16] = (target.atr_res[16] & 0xCF) | 0x20
+            target.atr_res = bytes(atr_res)
+
+        return target
+
+    def listen_tta(self, target, timeout):
+        """Listen *timeout* seconds for a Type A activation at 106 kbps. The
+        ``sens_res``, ``sdd_res``, and ``sel_res`` response data must
+        be provided and ``sdd_res`` must be a 4 byte UID that starts
+        with ``08h``. Depending on ``sel_res`` an activation may
+        return a target with a ``tt2_cmd``, ``tt4_cmd`` or ``atr_req``
+        attribute. The default RATS response sent for a Type 4 Tag
+        activation can be replaced with a ``rats_res`` attribute.
+
+        """
+        return super(Device, self).listen_tta(target, timeout)
+
+    def listen_ttb(self, target, timeout):
+        """Listen as Type B Target is not supported."""
+        info = "{device} does not support listen as Type B Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_ttf(self, target, timeout):
+        """Listen *timeout* seconds for a Type F card activation. The target
+        ``brty`` must be set to either 212F or 424F and ``sensf_res``
+        provide 19 byte response data (response code + 8 byte IDm + 8
+        byte PMm + 2 byte system code). Note that the maximum command
+        an response frame length is 64 bytes only (including the frame
+        length byte), because the driver must directly program the
+        contactless interface unit within the PN533.
+
+        """
+        return super(Device, self).listen_ttf(target, timeout)
+
+    def listen_dep(self, target, timeout):
+        """Listen *timeout* seconds to become initialized as a DEP Target.
+
+        The PN531 can be set to listen as a DEP Target for passive and
+        active communication mode.
+
+        """
+        return super(Device, self).listen_dep(target, timeout)
+
+    def _init_as_target(self, mode, tta_params, ttf_params, timeout):
+        nfcid3t = ttf_params[0:8] + b"\x00\x00"
+        args = (mode, tta_params, ttf_params, nfcid3t, b'', timeout)
+        return self.chipset.tg_init_tama_target(*args)
+
+
+def init(transport):
+    chipset = Chipset(transport, logger=log)
+    device = Device(chipset, logger=log)
+    device._vendor_name = transport.manufacturer_name
+    device._device_name = transport.product_name
+    return device

src/lib/nfc/clf/pn532.py

@@ -0,0 +1,454 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""Driver module for contactless devices based on the NXP PN532
+chipset. This successor of the PN531 can additionally handle Type B
+Technology (type 4B Tags) and Type 1 Tag communication. It also
+supports an extended frame syntax for host communication that allows
+larger packets to be transferred. The chip has selectable UART, I2C or
+SPI host interfaces. A speciality of the PN532 is that it can manage
+two targets (cards) simultanously, although this is not used by
+*nfcpy*.
+
+The internal chipset architecture comprises a small 8-bit MCU and a
+Contactless Interface Unit CIU that is basically a PN512. The CIU
+implements the analog and digital part of communication (modulation
+and framing) while the MCU handles the protocol parts and host
+communication. Almost all PN532 firmware limitations (or bugs) can be
+avoided by directly programming the CIU. Type F Target mode for card
+emulation is completely implemented with the CIU and limited to 64
+byte frame exchanges by the CIU's FIFO size. Type B Target mode is not
+possible.
+
+==========  =======  ============
+function    support  remarks
+==========  =======  ============
+sense_tta   yes
+sense_ttb   yes
+sense_ttf   yes
+sense_dep   yes
+listen_tta  yes
+listen_ttb  no
+listen_ttf  yes      Maximimum frame size is 64 byte
+listen_dep  yes
+==========  =======  ============
+
+"""
+import src.lib.nfc.clf
+from . import pn53x
+
+import os
+import sys
+import time
+import errno
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Chipset(pn53x.Chipset):
+    CMD = {
+        # Miscellaneous
+        0x00: "Diagnose",
+        0x02: "GetFirmwareVersion",
+        0x04: "GetGeneralStatus",
+        0x06: "ReadRegister",
+        0x08: "WriteRegister",
+        0x0C: "ReadGPIO",
+        0x0E: "WriteGPIO",
+        0x10: "SetSerialBaudrate",
+        0x12: "SetParameters",
+        0x14: "SAMConfiguration",
+        0x16: "PowerDown",
+        # RF communication
+        0x32: "RFConfiguration",
+        0x58: "RFRegulationTest",
+        # Initiator
+        0x56: "InJumpForDEP",
+        0x46: "InJumpForPSL",
+        0x4A: "InListPassiveTarget",
+        0x50: "InATR",
+        0x4E: "InPSL",
+        0x40: "InDataExchange",
+        0x42: "InCommunicateThru",
+        0x44: "InDeselect",
+        0x52: "InRelease",
+        0x54: "InSelect",
+        0x60: "InAutoPoll",
+        # Target
+        0x8C: "TgInitAsTarget",
+        0x92: "TgSetGeneralBytes",
+        0x86: "TgGetData",
+        0x8E: "TgSetData",
+        0x94: "TgSetMetaData",
+        0x88: "TgGetInitiatorCommand",
+        0x90: "TgResponseToInitiator",
+        0x8A: "TgGetTargetStatus",
+    }
+    ERR = {
+        0x01: "Time out, the Target has not answered",
+        0x02: "Checksum error during RF communication",
+        0x03: "Parity error during RF communication",
+        0x04: "Erroneous bit count in anticollision",
+        0x05: "Framing error during Mifare operation",
+        0x06: "Abnormal bit collision in 106 kbps anticollision",
+        0x07: "Insufficient communication buffer size",
+        0x09: "RF buffer overflow detected by CIU",
+        0x0a: "RF field not activated in time by active mode peer",
+        0x0b: "Protocol error during RF communication",
+        0x0d: "Overheated - antenna drivers deactivated",
+        0x0e: "Internal buffer overflow",
+        0x10: "Invalid command parameter",
+        0x12: "Unsupported command from Initiator",
+        0x13: "Format error during RF communication",
+        0x14: "Mifare authentication error",
+        0x23: "ISO/IEC14443-3 UID check byte is wrong",
+        0x25: "Command invalid in current DEP state",
+        0x26: "Operation not allowed in this configuration",
+        0x27: "Command is not acceptable in the current context",
+        0x29: "Released by Initiator while operating as Target",
+        0x2A: "ISO/IEC14443-3B, the ID of the card does not match",
+        0x2B: "ISO/IEC14443-3B, card previously activated has disappeared",
+        0x2C: "NFCID3i and NFCID3t mismatch in DEP 212/424 kbps passive",
+        0x2D: "An over-current event has been detected",
+        0x2E: "NAD missing in DEP frame",
+        0x7f: "Invalid command syntax - received error frame",
+        0xff: "Insufficient data received from executing chip command",
+    }
+
+    host_command_frame_max_size = 265
+    in_list_passive_target_max_target = 2
+    in_list_passive_target_brty_range = (0, 1, 2, 3, 4)
+
+    def _read_register(self, data):
+        return self.command(0x06, data, timeout=0.25)
+
+    def _write_register(self, data):
+        self.command(0x08, data, timeout=0.25)
+
+    def set_serial_baudrate(self, baudrate):
+        br = (9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600, 1288000)
+
+        self.command(0x10, bytearray([br.index(baudrate)]), timeout=0.1)
+        self.write_frame(self.ACK)
+        time.sleep(0.001)
+
+    def sam_configuration(self, mode, timeout=0, irq=False):
+        mode = ("normal", "virtual", "wired", "dual").index(mode) + 1
+        self.command(0x14, bytearray([mode, timeout, int(irq)]), timeout=0.1)
+
+    power_down_wakeup_src = ("INT0", "INT1", "rfu", "RF",
+                             "HSU", "SPI", "GPIO", "I2C")
+
+    def power_down(self, wakeup_enable, generate_irq=False):
+        wakeup_set = 0
+        for i, src in enumerate(self.power_down_wakeup_src):
+            if src in wakeup_enable:
+                wakeup_set |= 1 << i
+        cmd_data = bytearray([wakeup_set, int(generate_irq)])
+        data = self.command(0x16, cmd_data, timeout=0.1)
+        if data[0] != 0:
+            self.chipset_error(data)
+
+    def tg_init_as_target(self, mode, mifare_params, felica_params, nfcid3t,
+                          general_bytes=b'', historical_bytes=b'',
+                          timeout=None):
+        assert type(mode) is int and mode & 0b11111000 == 0
+        assert len(mifare_params) == 6
+        assert len(felica_params) == 18
+        assert len(nfcid3t) == 10
+
+        data = (bytearray([mode]) + mifare_params + felica_params + nfcid3t +
+                bytearray([len(general_bytes)]) + general_bytes +
+                bytearray([len(historical_bytes)]) + historical_bytes)
+        return self.command(0x8c, data, timeout)
+
+
+class Device(pn53x.Device):
+    # Device driver for PN532 based contactless frontends.
+
+    def __init__(self, chipset, logger):
+        assert isinstance(chipset, Chipset)
+        super(Device, self).__init__(chipset, logger)
+
+        ic, ver, rev, support = self.chipset.get_firmware_version()
+        self._chipset_name = "PN5{0:02x}v{1}.{2}".format(ic, ver, rev)
+        self.log.debug("chipset is a {0}".format(self._chipset_name))
+
+        self.chipset.set_parameters(0b00000000)
+        self.chipset.rf_configuration(0x02, b"\x00\x0B\x0A")
+        self.chipset.rf_configuration(0x04, b"\x00")
+        self.chipset.rf_configuration(0x05, b"\x01\x00\x01")
+
+        self.log.debug("write analog settings for Type A 106 kbps")
+        data = bytearray.fromhex("59 F4 3F 11 4D 85 61 6F 26 62 87")
+        self.chipset.rf_configuration(0x0A, data)
+
+        self.log.debug("write analog settings for Type F 212/424 kbps")
+        data = bytearray.fromhex("69 FF 3F 11 41 85 61 6F")
+        self.chipset.rf_configuration(0x0B, data)
+
+        self.log.debug("write analog settings for Type B 106 kbps")
+        data = bytearray.fromhex("FF 04 85")
+        self.chipset.rf_configuration(0x0C, data)
+
+        self.log.debug("write analog settings for 14443-4 212/424/848 kbps")
+        data = bytearray.fromhex("85 15 8A 85 08 B2 85 01 DA")
+        self.chipset.rf_configuration(0x0D, data)
+
+        self.mute()
+
+    def close(self):
+        # Cancel most recent command in case we've been interrupted
+        # before the response, give the chip 10 ms to think about it.
+        self.chipset.send_ack()
+        time.sleep(0.01)
+
+        # When using the high speed uart we must set the baud rate
+        # back to 115.2 kbps, otherwise we can't talk next time.
+        if self.chipset.transport.TYPE == "TTY":
+            self.chipset.set_serial_baudrate(115200)
+            self.chipset.transport.baudrate = 115200
+
+        # Set the chip to sleep mode with some wakeup sources.
+        self.chipset.power_down(wakeup_enable=("I2C", "SPI", "HSU"))
+        super(Device, self).close()
+
+    def sense_tta(self, target):
+        """Search for a Type A Target.
+
+        The PN532 can discover all kinds of Type A Targets (Type 1
+        Tag, Type 2 Tag, and Type 4A Tag) at 106 kbps.
+
+        """
+        return super(Device, self).sense_tta(target)
+
+    def sense_ttb(self, target):
+        """Search for a Type B Target.
+
+        The PN532 can discover Type B Targets (Type 4B Tag) at 106
+        kbps. For a Type 4B Tag the firmware automatically sends an
+        ATTRIB command that configures the use of DID and 64 byte
+        maximum frame size. The driver reverts this configuration with
+        a DESELECT and WUPB command to return the target prepared for
+        activation (which nfcpy does in the tag activation code).
+
+        """
+        return super(Device, self).sense_ttb(target, did=b'\x01')
+
+    def sense_ttf(self, target):
+        """Search for a Type F Target.
+
+        The PN532 can discover Type F Targets (Type 3 Tag) at 212 and
+        424 kbps. The driver uses the default polling command
+        ``06FFFF0000`` if no ``target.sens_req`` is supplied.
+
+        """
+        return super(Device, self).sense_ttf(target)
+
+    def sense_dep(self, target):
+        """Search for a DEP Target in active communication mode."""
+        return super(Device, self).sense_dep(target)
+
+    def _tt1_send_cmd_recv_rsp(self, data, timeout):
+        # Special handling for Tag Type 1 (Jewel/Topaz) card commands.
+
+        if data[0] in (0x00, 0x01, 0x1A, 0x53, 0x72):
+            # These commands are implemented by the chipset.
+            return self.chipset.in_data_exchange(data, timeout)[0]
+
+        if data[0] == 0x10:
+            # RSEG implementation does not accept any segment other
+            # than 0. Unfortunately we can not directly issue this
+            # command to the CIU because the response is 128 byte and
+            # we're not fast enough to read it from the 64 byte FIFO.
+            rsp = data[1:2]
+            for block in range((data[1] >> 4) * 16, (data[1] >> 4) * 16 + 16):
+                cmd = bytearray([0x02, block]) + data[2:]
+                rsp += self._tt1_send_cmd_recv_rsp(cmd, timeout)[1:9]
+            return rsp
+
+        # Remaining commands READ8, WRITE-E8, WRITE-NE8 are not
+        # implemented by the chipset. Fortunately we can directly
+        # program the CIU through register read/write. Each TT1
+        # command byte must be send as a separate Type A frame, the
+        # first as a short frame with only 7 data bits and the others
+        # as normal frames. Reading is also a bit complicated because
+        # for sending we have to disable the parity generator which
+        # means that we will also receive the parity bits, thus 9 bits
+        # received per 8 data bits. And because they are already
+        # reversed in the FIFO we must swap before parity removal and
+        # afterwards (maybe this could be optimized a bit)
+        data = self.add_crc_b(data)
+        register_write = []
+        register_write.append(("CIU_FIFOData",   data[0]))  # CMD_CODE
+        register_write.append(("CIU_BitFraming",    0x07))  # 7 bits
+        register_write.append(("CIU_Command",       0x04))  # Transmit
+        register_write.append(("CIU_BitFraming",    0x00))  # 8 bits
+        register_write.append(("CIU_ManualRCV",     0x30))  # ParityDisable
+        for i in range(1, len(data)):
+            register_write.append(("CIU_FIFOData", data[i]))  # CMD_DATA
+            register_write.append(("CIU_Command",     0x04))  # Transmit
+            register_write.append(("CIU_Command",     0x07))  # NoCmdChange
+        register_write.append(("CIU_Command",       0x08))    # Receive
+        self.chipset.write_register(*register_write)
+        if data[0] == 0x54:  # WRITE-E8
+            time.sleep(0.006)  # assuming same response time as WRITE-E
+        if data[0] == 0x1B:  # WRITE-NE8
+            time.sleep(0.003)  # assuming same response time as WRITE-NE
+        self.chipset.write_register(("CIU_ManualRCV", 0x20))  # enable parity
+        fifo_level = self.chipset.read_register("CIU_FIFOLevel")
+        if fifo_level == 0:
+            raise nfc.clf.TimeoutError
+        data = self.chipset.read_register(*(fifo_level * ["CIU_FIFOData"]))
+        data = ''.join(["{:08b}".format(octet)[::-1] for octet in data])
+        data = [int(data[i:i+8][::-1], 2) for i in range(0, len(data)-8, 9)]
+        if self.check_crc_b(data) is False:
+            raise nfc.clf.TransmissionError("crc_b check error")
+        return bytearray(data[0:-2])
+
+    def listen_tta(self, target, timeout):
+        """Listen *timeout* seconds for a Type A activation at 106 kbps. The
+        ``sens_res``, ``sdd_res``, and ``sel_res`` response data must
+        be provided and ``sdd_res`` must be a 4 byte UID that starts
+        with ``08h``. Depending on ``sel_res`` an activation may
+        return a target with a ``tt2_cmd``, ``tt4_cmd`` or ``atr_req``
+        attribute. The default RATS response sent for a Type 4 Tag
+        activation can be replaced with a ``rats_res`` attribute.
+
+        """
+        return super(Device, self).listen_tta(target, timeout)
+
+    def listen_ttb(self, target, timeout):
+        """Listen as Type B Target is not supported."""
+        info = "{device} does not support listen as Type B Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_ttf(self, target, timeout):
+        """Listen *timeout* seconds for a Type F card activation. The target
+        ``brty`` must be set to either 212F or 424F and ``sensf_res``
+        provide 19 byte response data (response code + 8 byte IDm + 8
+        byte PMm + 2 byte system code). Note that the maximum command
+        an response frame length is 64 bytes only (including the frame
+        length byte), because the driver must directly program the
+        contactless interface unit within the PN533.
+
+        """
+        return super(Device, self).listen_ttf(target, timeout)
+
+    def listen_dep(self, target, timeout):
+        """Listen *timeout* seconds to become initialized as a DEP Target.
+
+        The PN532 can be set to listen as a DEP Target for passive and
+        active communication mode.
+
+        """
+        return super(Device, self).listen_dep(target, timeout)
+
+    def _init_as_target(self, mode, tta_params, ttf_params, timeout):
+        nfcid3t = ttf_params[0:8] + b"\x00\x00"
+        args = (mode, tta_params, ttf_params, nfcid3t, b'', b'', timeout)
+        return self.chipset.tg_init_as_target(*args)
+
+
+def init(transport):
+    if transport.TYPE == "TTY":
+        baudrate = 115200  # PN532 initial baudrate
+        transport.open(transport.port, baudrate)
+        long_preamble = bytearray(10)
+
+        # The PN532 chip should send an ack within 15 ms after a
+        # command. We'll give it a bit more and wait 100 ms, unless
+        # we're on a Raspberry Pi detected by the Broadcom SOC. The
+        # USB on BCM270x has a nasty bug (may be SW or HW) that
+        # introduces additional up to ~1000 ms delay for the first
+        # data from a ttyUSB. Tested with two serial converters
+        # (PL2303 and FT232R) in loopback and it's reproducable adding
+        # up to 1000 ms if a serial open is done 1 sec after serial
+        # close. Waiting longer decreases that time until after 2 sec
+        # wait between close and open it all goes fine until the wait
+        # time reaches 3 seconds, and so on.
+        initial_timeout = 100   # milliseconds
+        # change_baudrate = True  # try higher speeds
+        change_baudrate = False  # MOD GG *DO NOT* try higher speeds
+        if sys.platform.startswith('linux'):
+            board = b""  # Raspi board will identify through device tree
+            try:
+                board = open('/proc/device-tree/model', "rb").read().strip(
+                        b'\x00')
+            except IOError:
+                pass
+            if board.startswith(b"Raspberry Pi"):
+                log.debug("running on {}".format(board))
+                if transport.port.startswith("/dev/ttyUSB"):
+                    log.debug("ttyUSB requires more time for first ack")
+                    initial_timeout = 1500  # milliseconds
+                elif transport.port == "/dev/ttyS0":
+                    log.debug("ttyS0 can only do 115.2 kbps")
+                    change_baudrate = False  # RPi 'mini uart'
+
+        get_version_cmd = bytearray.fromhex("0000ff02fed4022a00")
+        get_version_rsp = bytearray.fromhex("0000ff06fad50332")
+        transport.write(long_preamble + get_version_cmd)
+        log.debug("wait %d ms for data on %s", initial_timeout, transport.port)
+        if not transport.read(timeout=initial_timeout) == Chipset.ACK:
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+        if not transport.read(timeout=100).startswith(get_version_rsp):
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+        sam_configuration_cmd = bytearray.fromhex("0000ff05fbd4140100001700")
+        sam_configuration_rsp = bytearray.fromhex("0000ff02fed5151600")
+        transport.write(long_preamble + sam_configuration_cmd)
+        if not transport.read(timeout=100) == Chipset.ACK:
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+        if not transport.read(timeout=100) == sam_configuration_rsp:
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+        if sys.platform.startswith("linux") and change_baudrate is True:
+            stty = 'stty -F %s %%d 2> /dev/null' % transport.port
+            # MOD GG FIXED BAUD RATE
+            # for baudrate in (921600, 460800, 230400, 115200):
+            for baudrate in (115200,):
+                log.debug("trying to set %d baud", baudrate)
+                if os.system(stty % baudrate) == 0:
+                    os.system(stty % 115200)
+                    break
+
+        if baudrate > 115200:
+            set_baudrate_cmd = bytearray.fromhex("0000ff03fdd410000000")
+            set_baudrate_rsp = bytearray.fromhex("0000ff02fed5111a00")
+            set_baudrate_cmd[7] = 5 + (230400, 460800, 921600).index(baudrate)
+            set_baudrate_cmd[8] = 256 - sum(set_baudrate_cmd[5:8])
+            transport.write(long_preamble + set_baudrate_cmd)
+            if not transport.read(timeout=100) == Chipset.ACK:
+                raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+            if not transport.read(timeout=100) == set_baudrate_rsp:
+                raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+            transport.write(Chipset.ACK)
+            transport.open(transport.port, baudrate)
+            log.debug("changed uart speed to %d baud", baudrate)
+            time.sleep(0.001)
+
+        chipset = Chipset(transport, logger=log)
+        return Device(chipset, logger=log)
+
+    raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))

src/lib/nfc/clf/pn533.py

@@ -0,0 +1,399 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""Driver module for contactless devices based on the NXP PN533
+chipset. The PN533 is pretty similar to the PN532 except that it also
+has a USB host interface option and, probably due to the resources
+needed for USB, does not support two simultaneous targets. Anything
+else said about PN532 also applies to PN533.
+
+==========  =======  ============
+function    support  remarks
+==========  =======  ============
+sense_tta   yes
+sense_ttb   yes
+sense_ttf   yes
+sense_dep   yes
+listen_tta  yes
+listen_ttb  no
+listen_ttf  yes      Maximimum frame size is 64 byte
+listen_dep  yes
+==========  =======  ============
+
+"""
+import nfc.clf
+from . import pn53x
+
+import time
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Chipset(pn53x.Chipset):
+    CMD = {
+        # Miscellaneous
+        0x00: "Diagnose",
+        0x02: "GetFirmwareVersion",
+        0x04: "GetGeneralStatus",
+        0x06: "ReadRegister",
+        0x08: "WriteRegister",
+        0x0C: "ReadGPIO",
+        0x0E: "WriteGPIO",
+        0x12: "SetParameters",
+        0x18: "AlparCommandForTDA",
+        # RF Communication
+        0x32: "RFConfiguration",
+        0x58: "RFRegulationTest",
+        # Initiator
+        0x56: "InJumpForDEP",
+        0x46: "InJumpForPSL",
+        0x4A: "InListPassiveTarget",
+        0x50: "InATR",
+        0x4E: "InPSL",
+        0x40: "InDataExchange",
+        0x42: "InCommunicateThru",
+        0x38: "InQuartetByteExchange",
+        0x44: "InDeselect",
+        0x52: "InRelease",
+        0x54: "InSelect",
+        0x48: "InActivateDeactivatePaypass",
+        # Target
+        0x8C: "TgInitAsTarget",
+        0x92: "TgSetGeneralBytes",
+        0x86: "TgGetData",
+        0x8E: "TgSetData",
+        0x96: "TgSetDataSecure",
+        0x94: "TgSetMetaData",
+        0x98: "TgSetMetaDataSecure",
+        0x88: "TgGetInitiatorCommand",
+        0x90: "TgResponseToInitiator",
+        0x8A: "TgGetTargetStatus",
+    }
+    ERR = {
+        0x01: "Time out, the Target has not answered",
+        0x02: "Checksum error during RF communication",
+        0x03: "Parity error during RF communication",
+        0x04: "Erroneous bit count in anticollision",
+        0x05: "Framing error during mifare operation",
+        0x06: "Abnormal bit collision in 106 kbps anticollision",
+        0x07: "Insufficient communication buffer size",
+        0x09: "RF buffer overflow detected by CIU",
+        0x0a: "RF field not activated in time by active mode peer",
+        0x0b: "Protocol error during RF communication",
+        0x0d: "Overheated - antenna drivers deactivated",
+        0x0e: "Internal buffer overflow",
+        0x10: "Invalid command parameter",
+        0x12: "Unsupported command from Initiator",
+        0x13: "Format error during RF communication",
+        0x14: "Mifare authentication error",
+        0x18: "Target or Initiator does not support NFC Secure",
+        0x19: "I2C bus line is busy, a TDA transaction is ongoing",
+        0x23: "ISO/IEC14443-3 UID check byte is wrong",
+        0x25: "Command invalid in current DEP state",
+        0x26: "Operation not allowed in this configuration",
+        0x27: "Command is not acceptable due to the current context",
+        0x29: "Released by Initiator while operating as Target",
+        0x2A: "ISO/IEC14443-3B, the ID of the card does not match",
+        0x2B: "ISO/IEC14443-3B, card previously activated has disappeared",
+        0x2C: "NFCID3i and NFCID3t mismatch in DEP 212/424 kbps passive",
+        0x2D: "An over-current event has been detected",
+        0x2E: "NAD missing in DEP frame",
+        0x7f: "Invalid command syntax - received error frame",
+        0xff: "Insufficient data received from executing chip command",
+    }
+
+    host_command_frame_max_size = 265
+    in_list_passive_target_max_target = 1
+    in_list_passive_target_brty_range = (0, 1, 2, 3, 4, 6, 7, 8)
+
+    def get_general_status(self):
+        data = super(Chipset, self).get_general_status()
+        err = self.ERR.get(data[0], "error code 0x%02X" % data[0])
+        field = ("", "external field detected")[data[1]]
+        if data[2] == 1:
+            br_rx = (106, 212, 424, 848)[data[4]]
+            br_tx = (106, 212, 424, 848)[data[5]]
+            mtype = {0: "A/B", 1: "Active", 2: "Jewel", 16: "FeliCa"}[data[6]]
+            return err, field, (data[3], br_rx, br_tx, mtype)
+        else:
+            return err, field, None
+
+    def _read_register(self, data):
+        data = self.command(0x06, data, timeout=0.25)
+        if data[0] != 0:
+            self.chipset_error(data)
+        return data[1:]
+
+    def _write_register(self, data):
+        data = self.command(0x08, data, timeout=0.25)
+        if data[0] != 0:
+            self.chipset_error(data)
+
+    def tg_init_as_target(self, mode, mifare_params, felica_params,
+                          nfcid3t, gt, tk, timeout):
+        assert type(mode) is int and mode & 0b11111100 == 0
+        assert len(mifare_params) == 6
+        assert len(felica_params) == 18
+        assert len(nfcid3t) == 10
+
+        data = (bytearray([mode]) + mifare_params + felica_params + nfcid3t +
+                bytearray([len(gt)]) + gt + bytearray([len(tk)]) + tk)
+        return self.command(0x8c, data, timeout)
+
+
+class Device(pn53x.Device):
+    # Device driver for PN533 based contactless frontends.
+
+    def __init__(self, chipset, logger):
+        assert isinstance(chipset, Chipset)
+        super(Device, self).__init__(chipset, logger)
+
+        ic, ver, rev, support = self.chipset.get_firmware_version()
+        self._chipset_name = "PN5{0:02x}v{1}.{2}".format(ic, ver, rev)
+        self.log.debug("chipset is a {0}".format(self._chipset_name))
+
+        self.mute()
+        self.chipset.rf_configuration(0x02, b"\x00\x0B\x0A")
+        self.chipset.rf_configuration(0x04, b"\x00")
+        self.chipset.rf_configuration(0x05, b"\x01\x00\x01")
+        self.chipset.set_parameters(0b00000000)
+
+        self.eeprom = bytearray()
+        try:
+            self.chipset.read_register(0xA000)  # check access
+            for addr in range(0xA000, 0xA100, 64):
+                data = self.chipset.read_register(*range(addr, addr+64))
+                self.eeprom.extend(data)
+        except Chipset.Error:
+            self.log.debug("no eeprom attached")
+
+        if self.eeprom:
+            head = "EEPROM  " + ' '.join(["%2X" % i for i in range(16)])
+            self.log.debug(head)
+            for i in range(0, len(self.eeprom), 16):
+                data = ' '.join(["%02X" % x for x in self.eeprom[i:i+16]])
+                self.log.debug(('0x%04X: %s' % (0xA000+i, data)))
+        else:
+            self.log.debug("no eeprom attached")
+
+        self.log.debug("write analog settings for Type A 106 kbps")
+        data = bytearray.fromhex("5A F4 3F 11 4D 85 61 6F 26 62 87")
+        self.chipset.rf_configuration(0x0A, data)
+
+        self.log.debug("write analog settings for Type F 212/424 kbps")
+        data = bytearray.fromhex("6A FF 3F 10 41 85 61 6F")
+        self.chipset.rf_configuration(0x0B, data)
+
+        self.log.debug("write analog settings for Type B 106 kbps")
+        data = bytearray.fromhex("FF 04 85")
+        self.chipset.rf_configuration(0x0C, data)
+
+        self.log.debug("write analog settings for 14443-4 212/424/848 kbps")
+        data = bytearray.fromhex("85 15 8A 85 0A B2 85 04 DA")
+        self.chipset.rf_configuration(0x0D, data)
+
+    def close(self):
+        self.mute()
+        super(Device, self).close()
+
+    def sense_tta(self, target):
+        """Activate the RF field and probe for a Type A Target.
+
+        The PN533 can discover all kinds of Type A Targets (Type 1
+        Tag, Type 2 Tag, and Type 4A Tag) at 106 kbps.
+
+        """
+        return super(Device, self).sense_tta(target)
+
+    def sense_ttb(self, target):
+        """Activate the RF field and probe for a Type B Target.
+
+        The PN533 can discover Type B Targets (Type 4B Tag) at 106,
+        212, 424, and 848 kbps. The PN533 automatically sends an
+        ATTRIB command that configures a 64 byte maximum frame
+        size. The driver reverts this configuration with a DESELECT
+        and WUPB command to return the target prepared for activation.
+
+        """
+        return super(Device, self).sense_ttb(target)
+
+    def sense_ttf(self, target):
+        """Activate the RF field and probe for a Type F Target.
+
+        The PN533 can discover Type F Targets (Type 3 Tag) at 212 and
+        424 kbps.
+
+        """
+        return super(Device, self).sense_ttf(target)
+
+    def sense_dep(self, target):
+        """Search for a DEP Target in active communication mode."""
+        return super(Device, self).sense_dep(target)
+
+    def send_cmd_recv_rsp(self, target, data, timeout):
+        """Send command *data* to the remote *target* and return the response
+        data if received within *timeout* seconds.
+
+        """
+        return super(Device, self).send_cmd_recv_rsp(target, data, timeout)
+
+    def _tt1_send_cmd_recv_rsp(self, data, timeout):
+        # Special handling for Tag Type 1 (Jewel/Topaz) card commands.
+
+        if data[0] in (0x00, 0x01, 0x1A, 0x53, 0x72):
+            # RALL, READ, WRITE-NE, WRITE-E, RID are properly
+            # implemented by the PN533 firmware.
+            return self.chipset.in_data_exchange(data, timeout)[0]
+
+        if data[0] == 0x10:
+            # RSEG implementation does not accept any segment other
+            # than 0. Unfortunately we can not directly issue this
+            # command to the CIU because the response is 128 byte and
+            # we're not fast enough to read it from the 64 byte FIFO.
+            rsp = data[1:2]
+            for block in range((data[1] >> 4) * 16, (data[1] >> 4) * 16 + 16):
+                cmd = bytearray([0x02, block]) + data[2:]
+                rsp += self._tt1_send_cmd_recv_rsp(cmd, timeout)[1:9]
+            return rsp
+
+        # Remaining commands READ8, WRITE-E8, WRITE-NE8 are not
+        # implemented by the chipset. Fortunately we can directly
+        # program the CIU through register read/write. Each TT1
+        # command byte must be send as a separate Type A frame, the
+        # first is a short frame with only 7 data bits and the others
+        # are normal frames. Reading is also a bit complicated because
+        # for sending we have to disable the parity generator which
+        # means that we will also receive the parity bits, thus 9 bits
+        # received per 8 data bits. And because they are already
+        # reversed in the FIFO we must swap before parity removal and
+        # afterwards (maybe this could be a bit more optimized).
+        data = self.add_crc_b(data)
+        self.chipset.write_register(
+            ("CIU_FIFOData", data[0]),  # CMD_CODE
+            ("CIU_ManualRCV",  0x10),   # ParityDisable
+            ("CIU_BitFraming", 0x07),   # 7 bits
+            ("CIU_Command",    0x04),   # Transmit
+        )
+        for i in range(1, len(data)-1):
+            self.chipset.write_register(
+                ("CIU_FIFOData", data[i]),  # CMD_DATA
+                ("CIU_BitFraming", 0x00),   # 8 bits
+                ("CIU_Command",    0x04),   # Transmit
+            )
+        self.chipset.write_register(
+            ("CIU_FIFOData", data[-1]),  # CMD_DATA
+            ("CIU_Command",    0x0C),    # Transceive
+            ("CIU_BitFraming", 0x80),    # 8 bits, start send
+        )
+        if data[0] == 0x54:  # WRITE-E8
+            time.sleep(0.006)  # assuming same response time as WRITE-E
+        if data[0] == 0x1B:  # WRITE-NE8
+            time.sleep(0.003)  # assuming same response time as WRITE-NE
+        self.chipset.write_register(("CIU_ManualRCV", 0x00))  # enable parity
+        fifo_level = self.chipset.read_register("CIU_FIFOLevel")
+        if fifo_level == 0:
+            raise nfc.clf.TimeoutError
+        data = self.chipset.read_register(*(fifo_level * ["CIU_FIFOData"]))
+        data = ''.join(["{:08b}".format(octet)[::-1] for octet in data])
+        data = [int(data[i:i+8][::-1], 2) for i in range(0, len(data)-8, 9)]
+        if self.check_crc_b(data) is False:
+            raise nfc.clf.TransmissionError("crc_b check error")
+        return bytearray(data[:-2])
+
+    def listen_tta(self, target, timeout):
+        """Listen *timeout* seconds for a Type A activation at 106 kbps. The
+        ``sens_res``, ``sdd_res``, and ``sel_res`` response data must
+        be provided and ``sdd_res`` must be a 4 byte UID that starts
+        with ``08h``. Depending on ``sel_res`` an activation may
+        return a target with a ``tt2_cmd``, ``tt4_cmd`` or ``atr_req``
+        attribute. The default RATS response sent for a Type 4 Tag
+        activation can be replaced with a ``rats_res`` attribute.
+
+        """
+        return super(Device, self).listen_tta(target, timeout)
+
+    def listen_ttb(self, target, timeout):
+        """Listen as Type B Target is not supported."""
+        info = "{device} does not support listen as Type B Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_ttf(self, target, timeout):
+        """Listen *timeout* seconds for a Type F card activation. The target
+        ``brty`` must be set to either 212F or 424F and ``sensf_res``
+        provide 19 byte response data (response code + 8 byte IDm + 8
+        byte PMm + 2 byte system code). Note that the maximum command
+        an response frame length is 64 bytes only (including the frame
+        length byte), because the driver must directly program the
+        contactless interface unit within the PN533.
+
+        """
+        return super(Device, self).listen_ttf(target, timeout)
+
+    def listen_dep(self, target, timeout):
+        """Listen *timeout* seconds to become initialized as a DEP Target.
+
+        The PN533 can be set to listen as a DEP Target for passive and
+        active communication mode.
+
+        """
+        return super(Device, self).listen_dep(target, timeout)
+
+    def send_rsp_recv_cmd(self, target, data, timeout):
+        """While operating as *target* send response *data* to the remote
+        device and return new command data if received within
+        *timeout* seconds.
+
+        """
+        return super(Device, self).send_rsp_recv_cmd(target, data, timeout)
+
+    def _init_as_target(self, mode, tta_params, ttf_params, timeout):
+        nfcid3t = ttf_params[0:8] + b"\x00\x00"
+        args = (mode, tta_params, ttf_params, nfcid3t, b'', b'', timeout)
+        return self.chipset.tg_init_as_target(*args)
+
+
+def init(transport):
+    # write ack to perform a soft reset, raises IOError(EACCES) if
+    # someone else has already claimed the USB device.
+    transport.write(Chipset.ACK)
+
+    chipset = Chipset(transport, logger=log)
+    device = Device(chipset, logger=log)
+
+    # PN533 bug: Manufacturer and product strings are no longer
+    # accessible from USB device description after first use with
+    # slightly larger command frames. Better read it from EEPROM.
+    if device.eeprom:
+        index = 0
+        while index < len(device.eeprom) and device.eeprom[index] != 0xFF:
+            tlv_tag, tlv_len = device.eeprom[index], device.eeprom[index+1]
+            tlv_data = device.eeprom[index+2:index+2+tlv_len]
+            if tlv_tag == 3:
+                device._device_name = tlv_data[2:].decode("utf-16-le")
+            if tlv_tag == 4:
+                device._vendor_name = tlv_data[2:].decode("utf-16-le")
+            index += 2 + tlv_len
+    else:
+        device._vendor_name = "SensorID"
+        device._device_name = "StickID"
+
+    return device

src/lib/nfc/clf/rcs380.py

@@ -0,0 +1,986 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2012, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""Driver module for contactless devices based on the Sony NFC Port-100
+chipset. The only product known to use this chipset is the PaSoRi
+RC-S380. The RC-S380 connects to the host as a native USB device.
+
+The RC-S380 has been the first NFC Forum certified device. It supports
+reading and writing of all NFC Forum tags as well as peer-to-peer
+mode. In addition, the NFC Port-100 also supports card emulation Type
+A and Type F Technology. A notable restriction is that peer-to-peer
+active communication mode (not required for NFC Forum certification)
+is not supported.
+
+==========  =======  ============
+function    support  remarks
+==========  =======  ============
+sense_tta   yes
+sense_ttb   yes
+sense_ttf   yes
+sense_dep   no
+listen_tta  yes      Type F responses can not be disabled
+listen_ttb  no
+listen_ttf  yes
+listen_dep  yes      Only passive communication mode
+==========  =======  ============
+
+"""
+import nfc.clf
+from . import device
+
+import time
+import struct
+import operator
+from functools import reduce
+from binascii import hexlify
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Frame(object):
+    def __init__(self, data):
+        self._data = None
+        self._type = None
+        self._frame = None
+
+        if data[0:3] == bytearray(b"\x00\x00\xff"):
+            frame = bytearray(data)
+            if frame == bytearray(b"\x00\x00\xff\x00\xff\x00"):
+                self._type = "ack"
+            elif frame == bytearray(b"\x00\x00\xFF\xFF\xFF"):
+                self._type = "err"
+            elif frame[3:5] == bytearray(b"\xff\xff"):
+                self._type = "data"
+            if self.type == "data":
+                length = struct.unpack("<H", bytes(frame[5:7]))[0]
+                self._data = frame[8:8+length]
+        else:
+            frame = bytearray([0, 0, 255, 255, 255])
+            frame += bytearray(struct.pack("<H", len(data)))
+            frame += bytearray(struct.pack("B", (256 - sum(frame[5:7])) % 256))
+            frame += bytearray(data)
+            frame += bytearray([(256 - sum(frame[8:])) % 256, 0])
+            self._frame = frame
+
+    def __str__(self):
+        return str(self._frame)
+
+    def __bytes__(self):
+        return bytes(self._frame)
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def data(self):
+        return self._data
+
+
+class CommunicationError(Exception):
+    err2str = {0x00000000: "NO_ERROR",
+               0x00000001: "PROTOCOL_ERROR",
+               0x00000002: "PARITY_ERROR",
+               0x00000004: "CRC_ERROR",
+               0x00000008: "COLLISION_ERROR",
+               0x00000010: "OVERFLOW_ERROR",
+               0x00000040: "TEMPERATURE_ERROR",
+               0x00000080: "RECEIVE_TIMEOUT_ERROR",
+               0x00000100: "CRYPTO1_ERROR",
+               0x00000200: "RFCA_ERROR",
+               0x00000400: "RF_OFF_ERROR",
+               0x00000800: "TRANSMIT_TIMEOUT_ERROR",
+               0x80000000: "RECEIVE_LENGTH_ERROR"
+               }
+    str2err = dict([(v, k) for k, v in err2str.items()])
+
+    def __init__(self, status_bytes):
+        self.errno = struct.unpack('<L', status_bytes)[0]
+
+    def __eq__(self, strerr):
+        errno = CommunicationError.str2err[strerr]
+        return bool(self.errno & errno) if self.errno or errno else True
+
+    def __ne__(self, strerr):
+        return not self.__eq__(strerr)
+
+    def __str__(self):
+        return self.__class__.__name__ + ' ' + CommunicationError.err2str.get(
+            self.errno, "0x{0:08X}".format(self.errno))
+
+
+class StatusError(Exception):
+    err2str = ("SUCCESS", "PARAMETER_ERROR", "PB_ERROR", "RFCA_ERROR",
+               "TEMPERATURE_ERROR", "PWD_ERROR", "RECEIVE_ERROR",
+               "COMMANDTYPE_ERROR")
+
+    def __init__(self, status):
+        self.errno = status
+
+    def __str__(self):
+        try:
+            return StatusError.err2str[self.errno]
+        except IndexError:
+            return "UNKNOWN STATUS ERROR 0x{:02X}".format(self.errno)
+
+
+class Chipset(object):
+    ACK = bytearray.fromhex('0000FF00FF00')
+    CMD = {
+        # RF Communication
+        0x00: "InSetRF",
+        0x02: "InSetProtocol",
+        0x04: "InCommRF",
+        0x06: "SwitchRF",
+        0x10: "MaintainFlash",
+        0x12: "ResetDevice",
+        0x20: "GetFirmwareVersion",
+        0x22: "GetPDDataVersion",
+        0x24: "GetProperty",
+        0x26: "InGetProtocol",
+        0x28: "GetCommandType",
+        0x2A: "SetCommandType",
+        0x30: "InSetRCT",
+        0x32: "InGetRCT",
+        0x34: "GetPDData",
+        0x36: "ReadRegister",
+        0x40: "TgSetRF",
+        0x42: "TgSetProtocol",
+        0x44: "TgSetAuto",
+        0x46: "TgSetRFOff",
+        0x48: "TgCommRF",
+        0x50: "TgGetProtocol",
+        0x60: "TgSetRCT",
+        0x62: "TgGetRCT",
+        0xF0: "Diagnose",
+    }
+
+    def __init__(self, transport, logger):
+        self.transport = transport
+        self.log = logger
+
+        # write ack to perform a soft reset
+        # raises IOError(EACCES) if we're second
+        self.transport.write(Chipset.ACK)
+
+        # Clear any response data that may be leftover from the last
+        # session when it was killed.
+        try:
+            while True:
+                data = self.transport.read(timeout=10)
+                log.debug("cleared garbage %s", hexlify(data).decode())
+        except IOError:
+            pass
+
+        # do some basic initialization and deactivate rf
+        self.set_command_type(1)
+        self.get_firmware_version()
+        self.get_pd_data_version()
+        self.switch_rf("off")
+
+    def close(self):
+        self.switch_rf('off')
+        self.transport.write(Chipset.ACK)
+        self.transport.close()
+        self.transport = None
+
+    def send_command(self, cmd_code, cmd_data):
+        cmd_data = bytearray(cmd_data)
+        log.log(logging.DEBUG-1, "{} {}".format(self.CMD[cmd_code],
+                                                hexlify(cmd_data).decode()))
+        if self.transport is not None:
+            cmd = bytearray([0xD6, cmd_code]) + cmd_data
+            self.transport.write(bytes(Frame(cmd)))
+            ack = Frame(self.transport.read())
+            if ack.type == 'ack':
+                rsp = Frame(self.transport.read())
+                if rsp.type == 'data':
+                    if rsp.data[0] == 0xD7 and rsp.data[1] == cmd_code + 1:
+                        return rsp.data[2:]
+                    else:
+                        logmsg = "expected rsp code D7{:02X} not {:02X}{:02X}"
+                        log.error(logmsg.format(cmd_code+1, *rsp.data[0:2]))
+                else:
+                    log.error("expected data but got {}".format(rsp.type))
+            else:
+                log.error("expected ack but got {}".format(ack.type))
+        else:
+            log.debug("transport closed in send_command")
+
+    def in_set_rf(self, brty_send, brty_recv=None):
+        settings = {
+            "212F": (1, 1, 15, 1), "424F": (1, 2, 15, 2),
+            "106A": (2, 3, 15, 3), "212A": (4, 4, 15, 4),
+            "424A": (5, 5, 15, 5), "106B": (3, 7, 15, 7),
+            "212B": (3, 8, 15, 8), "424B": (3, 9, 15, 9),
+        }
+        if brty_recv is None:
+            brty_recv = brty_send
+        data = settings[brty_send][0:2] + settings[brty_recv][2:4]
+        data = self.send_command(0x00, data)
+        if data and data[0] != 0:
+            raise StatusError(data[0])
+
+    in_set_protocol_defaults = bytearray.fromhex(
+        "0018 0101 0201 0300 0400 0500 0600 0708 0800 0900"
+        "0A00 0B00 0C00 0E04 0F00 1000 1100 1200 1306")
+
+    def in_set_protocol(self, data=None, **kwargs):
+        data = bytearray() if data is None else bytearray(data)
+        KEYS = ("initial_guard_time", "add_crc", "check_crc", "multi_card",
+                "add_parity", "check_parity", "bitwise_anticoll",
+                "last_byte_bit_count", "mifare_crypto", "add_sof",
+                "check_sof", "add_eof", "check_eof", "rfu", "deaf_time",
+                "continuous_receive_mode", "min_len_for_crm",
+                "type_1_tag_rrdd", "rfca", "guard_time")
+        for key, value in sorted(kwargs.items()):
+            data.extend(bytearray([KEYS.index(key), int(value)]))
+        if len(data) > 0:
+            data = self.send_command(0x02, data)
+            if data and data[0] != 0:
+                raise StatusError(data[0])
+
+    def in_comm_rf(self, data, timeout):
+        timeout = min((timeout + (1 if timeout > 0 else 0)) * 10, 0xFFFF)
+        data = self.send_command(0x04,
+                                 struct.pack("<H", timeout) + bytes(data))
+        if data and tuple(data[0:4]) != (0, 0, 0, 0):
+            raise CommunicationError(data[0:4])
+        return data[5:] if data else None
+
+    def switch_rf(self, switch):
+        switch = ("off", "on").index(switch)
+        data = self.send_command(0x06, [switch])
+        if data and data[0] != 0:
+            raise StatusError(data[0])
+
+    def tg_set_rf(self, comm_type):
+        tg_comm_type = {"106A": (8, 11), "212F": (8, 12), "424F": (8, 13),
+                        "212A": (8, 14), "424A": (8, 15)}
+
+        comm_type = tg_comm_type[comm_type]
+        data = self.send_command(0x40, comm_type)
+        if data and data[0] != 0:
+            raise StatusError(data[0])
+
+    tg_set_protocol_defaults = bytearray.fromhex("0001 0101 0207")
+
+    def tg_set_protocol(self, data=None, **kwargs):
+        data = bytearray() if data is None else bytearray(data)
+        KEYS = ("send_timeout_time_unit", "rf_off_error",
+                "continuous_receive_mode")
+        for key, value in sorted(kwargs.items()):
+            data.extend(bytearray([KEYS.index(key), int(value)]))
+        data = self.send_command(0x42, bytearray(data))
+        if data and data[0] != 0:
+            raise StatusError(data[0])
+
+    def tg_set_auto(self, data):
+        data = self.send_command(0x44, data)
+        if data and data[0] != 0:
+            raise StatusError(data[0])
+
+    def tg_comm_rf(self, guard_time=0, send_timeout=0xFFFF,
+                   mdaa=False, nfca_params=b'', nfcf_params=b'',
+                   mf_halted=False, arae=False, recv_timeout=0,
+                   transmit_data=None):
+        # Send a response packet and receive the next request. If
+        # *transmit_data* is None skip sending. If *recv_timeout* is
+        # zero skip receiving. Data is sent only between *guard_time*
+        # and *send_timeout*, measured from the end of the last
+        # received data. If *mdaa* is True, reply to Type A and Type F
+        # activation commands with *nfca_params* (sens_res, nfcid1-3,
+        # sel_res) and *nfcf_params* (idm, pmm, system_code).
+        data = struct.pack("<HH?6s18s??H", guard_time, send_timeout,
+                           mdaa, bytes(nfca_params), bytes(nfcf_params),
+                           mf_halted, arae, recv_timeout)
+        if transmit_data:
+            data = data + bytes(transmit_data)
+
+        data = self.send_command(0x48, data)
+
+        if data and tuple(data[3:7]) != (0, 0, 0, 0):
+            raise CommunicationError(data[3:7])
+
+        return data
+
+    def reset_device(self, startup_delay=0):
+        self.send_command(0x12, struct.pack("<H", startup_delay))
+        self.transport.write(Chipset.ACK)
+        time.sleep(float(startup_delay + 500)/1000)
+
+    def get_firmware_version(self, option=None):
+        assert option in (None, 0x60, 0x61, 0x80)
+        data = self.send_command(0x20, [option] if option else [])
+        log.debug("firmware version {1:x}.{0:02x}".format(*data))
+        return data
+
+    def get_pd_data_version(self):
+        data = self.send_command(0x22, [])
+        log.debug("package data format {1:x}.{0:02x}".format(*data))
+
+    def get_command_type(self):
+        data = self.send_command(0x28, [])
+        return struct.unpack(">Q", data[0:8])[0]
+
+    def set_command_type(self, command_type):
+        data = self.send_command(0x2A, [command_type])
+        if data and data[0] != 0:
+            raise StatusError(data[0])
+
+
+class Device(device.Device):
+    # Device driver for the Sony NFC Port-100 chipset.
+
+    def __init__(self, chipset, logger):
+        self.chipset = chipset
+        self.log = logger
+
+        minor, major = self.chipset.get_firmware_version()
+        self._chipset_name = "NFC Port-100 v{0:x}.{1:02x}".format(major, minor)
+
+    def close(self):
+        self.chipset.close()
+        self.chipset = None
+
+    def mute(self):
+        self.chipset.switch_rf("off")
+
+    def sense_tta(self, target):
+        """Sense for a Type A Target is supported for 106, 212 and 424
+        kbps. However, there may not be any target that understands the
+        activation commands in other than 106 kbps.
+
+        """
+        log.debug("polling for NFC-A technology")
+
+        if target.brty not in ("106A", "212A", "424A"):
+            message = "unsupported bitrate {0}".format(target.brty)
+            raise nfc.clf.UnsupportedTargetError(message)
+
+        self.chipset.in_set_rf(target.brty)
+        self.chipset.in_set_protocol(self.chipset.in_set_protocol_defaults)
+        self.chipset.in_set_protocol(initial_guard_time=6, add_crc=0,
+                                     check_crc=0, check_parity=1,
+                                     last_byte_bit_count=7)
+
+        sens_req = (target.sens_req if target.sens_req else
+                    bytearray.fromhex("26"))
+
+        try:
+            sens_res = self.chipset.in_comm_rf(sens_req, 30)
+            if len(sens_res) != 2:
+                return None
+        except CommunicationError as error:
+            if error != "RECEIVE_TIMEOUT_ERROR":
+                log.debug(error)
+            return None
+
+        log.debug("rcvd SENS_RES %s", hexlify(sens_res).decode())
+
+        if sens_res[0] & 0x1F == 0:
+            log.debug("type 1 tag target found")
+            self.chipset.in_set_protocol(last_byte_bit_count=8, add_crc=2,
+                                         check_crc=2, type_1_tag_rrdd=2)
+            target = nfc.clf.RemoteTarget(target.brty, sens_res=sens_res)
+            if sens_res[1] & 0x0F == 0b1100:
+                rid_cmd = bytearray.fromhex("78 0000 00000000")
+                log.debug("send RID_CMD %s", hexlify(rid_cmd).decode())
+                try:
+                    target.rid_res = self.chipset.in_comm_rf(rid_cmd, 30)
+                except CommunicationError as error:
+                    log.debug(error)
+                    return None
+            return target
+
+        # other than type 1 tag
+        try:
+            self.chipset.in_set_protocol(last_byte_bit_count=8, add_parity=1)
+            if target.sel_req:
+                uid = target.sel_req
+                if len(uid) > 4:
+                    uid = b"\x88" + uid
+                if len(uid) > 8:
+                    uid = uid[0:4] + b"\x88" + uid[4:]
+                self.chipset.in_set_protocol(add_crc=1, check_crc=1)
+                for i, sel_cmd in zip(range(0, len(uid), 4), b"\x93\x95\x97"):
+                    sel_req = bytearray([sel_cmd, 0x70]) + uid[i:i+4]
+                    sel_req.append(reduce(operator.xor, sel_req[2:6]))  # BCC
+                    log.debug("send SEL_REQ %s", hexlify(sel_req).decode())
+                    sel_res = self.chipset.in_comm_rf(sel_req, 30)
+                    log.debug("rcvd SEL_RES %s", hexlify(sel_res).decode())
+                uid = target.sel_req
+            else:
+                uid = bytearray()
+                for sel_cmd in b"\x93\x95\x97":
+                    self.chipset.in_set_protocol(add_crc=0, check_crc=0)
+                    sdd_req = bytearray([sel_cmd, 0x20])
+                    log.debug("send SDD_REQ %s", hexlify(sdd_req).decode())
+                    sdd_res = self.chipset.in_comm_rf(sdd_req, 30)
+                    log.debug("rcvd SDD_RES %s", hexlify(sdd_res).decode())
+                    self.chipset.in_set_protocol(add_crc=1, check_crc=1)
+                    sel_req = bytearray([sel_cmd, 0x70]) + sdd_res
+                    log.debug("send SEL_REQ %s", hexlify(sel_req).decode())
+                    sel_res = self.chipset.in_comm_rf(sel_req, 30)
+                    log.debug("rcvd SEL_RES %s", hexlify(sel_res).decode())
+                    if sel_res[0] & 0b00000100:
+                        uid = uid + sdd_res[1:4]
+                    else:
+                        uid = uid + sdd_res[0:4]
+                        break
+            if sel_res[0] & 0b00000100 == 0:
+                return nfc.clf.RemoteTarget(target.brty, sens_res=sens_res,
+                                            sel_res=sel_res, sdd_res=uid)
+        except CommunicationError as error:
+            log.debug(error)
+
+    def sense_ttb(self, target):
+        """Sense for a Type B Target is supported for 106, 212 and 424
+        kbps. However, there may not be any target that understands the
+        activation command in other than 106 kbps.
+
+        """
+        log.debug("polling for NFC-B technology")
+
+        if target.brty not in ("106B", "212B", "424B"):
+            message = "unsupported bitrate {0}".format(target.brty)
+            raise nfc.clf.UnsupportedTargetError(message)
+
+        self.chipset.in_set_rf(target.brty)
+        self.chipset.in_set_protocol(self.chipset.in_set_protocol_defaults)
+        self.chipset.in_set_protocol(initial_guard_time=20, add_sof=1,
+                                     check_sof=1, add_eof=1, check_eof=1)
+
+        sensb_req = (target.sensb_req if target.sensb_req else
+                     bytearray.fromhex("050010"))
+
+        log.debug("send SENSB_REQ %s", hexlify(sensb_req).decode())
+        try:
+            sensb_res = self.chipset.in_comm_rf(sensb_req, 30)
+        except CommunicationError as error:
+            if error != "RECEIVE_TIMEOUT_ERROR":
+                log.debug(error)
+            return None
+
+        if len(sensb_res) >= 12 and sensb_res[0] == 0x50:
+            log.debug("rcvd SENSB_RES %s", hexlify(sensb_res).decode())
+            return nfc.clf.RemoteTarget(target.brty, sensb_res=sensb_res)
+
+    def sense_ttf(self, target):
+        """Sense for a Type F Target is supported for 212 and 424 kbps.
+
+        """
+        log.debug("polling for NFC-F technology")
+
+        if target.brty not in ("212F", "424F"):
+            message = "unsupported bitrate {0}".format(target.brty)
+            raise nfc.clf.UnsupportedTargetError(message)
+
+        self.chipset.in_set_rf(target.brty)
+        self.chipset.in_set_protocol(self.chipset.in_set_protocol_defaults)
+        self.chipset.in_set_protocol(initial_guard_time=24)
+
+        sensf_req = (target.sensf_req if target.sensf_req else
+                     bytearray.fromhex("00FFFF0100"))
+
+        log.debug("send SENSF_REQ %s", hexlify(sensf_req).decode())
+        try:
+            frame = bytearray([len(sensf_req)+1]) + sensf_req
+            frame = self.chipset.in_comm_rf(frame, 10)
+        except CommunicationError as error:
+            if error != "RECEIVE_TIMEOUT_ERROR":
+                log.debug(error)
+            return None
+
+        if 18 <= len(frame) == frame[0] and frame[1] == 1:
+            log.debug("rcvd SENSF_RES %s", hexlify(frame[1:]).decode())
+            return nfc.clf.RemoteTarget(target.brty, sensf_res=frame[1:])
+
+    def sense_dep(self, target):
+        """Sense for an active DEP Target is not supported. The device only
+        supports passive activation via sense_tta/sense_ttf.
+
+        """
+        message = "{device} does not support sense for active DEP Target"
+        raise nfc.clf.UnsupportedTargetError(message.format(device=self))
+
+    def listen_tta(self, target, timeout):
+        """Listen as Type A Target in 106 kbps.
+
+        Restrictions:
+
+        * It is not possible to send short frames that are required
+          for ACK and NAK responses. This means that a Type 2 Tag
+          emulation can only implement a single sector memory model.
+
+        * It can not be avoided that the chipset responds to SENSF_REQ
+          commands. The driver configures the SENSF_RES response to
+          all zero and ignores all Type F communication but eventually
+          it depends on the remote device whether Type A Target
+          activation will still be attempted.
+
+        """
+        if not target.brty == '106A':
+            info = "unsupported target bitrate: %r" % target.brty
+            raise nfc.clf.UnsupportedTargetError(info)
+
+        if target.rid_res:
+            info = "listening for type 1 tag activation is not supported"
+            raise nfc.clf.UnsupportedTargetError(info)
+
+        if target.sens_res is None:
+            raise ValueError("sens_res is required")
+        if target.sdd_res is None:
+            raise ValueError("sdd_res is required")
+        if target.sel_res is None:
+            raise ValueError("sel_res is required")
+        if len(target.sens_res) != 2:
+            raise ValueError("sens_res must be 2 byte")
+        if len(target.sdd_res) != 4:
+            raise ValueError("sdd_res must be 4 byte")
+        if len(target.sel_res) != 1:
+            raise ValueError("sel_res must be 1 byte")
+        if target.sdd_res[0] != 0x08:
+            raise ValueError("sdd_res[0] must be 08h")
+
+        nfca_params = target.sens_res + target.sdd_res[1:4] + target.sel_res
+        log.debug("nfca_params %s", hexlify(nfca_params).decode())
+
+        self.chipset.tg_set_rf("106A")
+        self.chipset.tg_set_protocol(self.chipset.tg_set_protocol_defaults)
+        self.chipset.tg_set_protocol(rf_off_error=False)
+
+        time_to_return = time.time() + timeout
+        tg_comm_rf_args = {'mdaa': True, 'nfca_params': nfca_params}
+        tg_comm_rf_args['recv_timeout'] = min(int(1000 * timeout), 0xFFFF)
+
+        def listen_tta_tt2():
+            recv_timeout = tg_comm_rf_args['recv_timeout']
+            while recv_timeout > 0:
+                log.debug("wait %d ms for Type 2 Tag activation", recv_timeout)
+                try:
+                    data = self.chipset.tg_comm_rf(**tg_comm_rf_args)
+                except CommunicationError as error:
+                    log.debug(error)
+                else:
+                    brty = ('106A', '212F', '424F')[data[0]-11]
+                    log.debug("%s rcvd %s",
+                              brty, hexlify(memoryview(data)[7:]).decode())
+                    if brty == "106A" and data[2] & 0x03 == 3:
+                        self.chipset.tg_set_protocol(rf_off_error=True)
+                        return nfc.clf.LocalTarget(
+                            "106A", sens_res=nfca_params[0:2],
+                            sdd_res=b'\x08'+nfca_params[2:5],
+                            sel_res=nfca_params[5:6], tt2_cmd=data[7:])
+                    else:
+                        log.debug("not a 106A Type 2 Tag command")
+                finally:
+                    recv_timeout = int(1000 * (time_to_return - time.time()))
+                    tg_comm_rf_args['recv_timeout'] = recv_timeout
+
+        def listen_tta_tt4():
+            rats_cmd = rats_res = None
+            recv_timeout = tg_comm_rf_args['recv_timeout']
+            while recv_timeout > 0:
+                log.debug("wait %d ms for 106A TT4 command", recv_timeout)
+                try:
+                    data = self.chipset.tg_comm_rf(**tg_comm_rf_args)
+                    tg_comm_rf_args['transmit_data'] = None
+                except CommunicationError as error:
+                    tg_comm_rf_args['transmit_data'] = None
+                    rats_cmd = rats_res = None
+                    log.debug(error)
+                else:
+                    brty = ('106A', '212F', '424F')[data[0]-11]
+                    log.debug("%s rcvd %s", brty,
+                              hexlify(memoryview(data)[7:]).decode())
+                    if brty == "106A" and data[2] == 3 and data[7] == 0xE0:
+                        (rats_cmd, rats_res) = (data[7:], target.rats_res)
+                        log.debug("rcvd RATS_CMD %s",
+                                  hexlify(rats_cmd).decode())
+                        if rats_res is None:
+                            rats_res = bytearray.fromhex("05 78 80 70 02")
+                        log.debug("send RATS_RES %s",
+                                  hexlify(rats_res).decode())
+                        tg_comm_rf_args['transmit_data'] = rats_res
+                    elif brty == "106A" and data[7] != 0xF0 and rats_cmd:
+                        did = rats_cmd[1] & 0x0F
+                        cmd = data[7:]
+                        ta_tb_tc = rats_res[2:]
+                        ta = ta_tb_tc.pop(0) if rats_res[1] & 0x10 else None
+                        tb = ta_tb_tc.pop(0) if rats_res[1] & 0x20 else None
+                        tc = ta_tb_tc.pop(0) if rats_res[1] & 0x40 else None
+                        if ta is not None:
+                            log.debug("TA(1) = {:08b}".format(ta))
+                        if tb is not None:
+                            log.debug("TB(1) = {:08b}".format(tb))
+                        if tc is not None:
+                            log.debug("TC(1) = {:08b}".format(tc))
+                        if ta_tb_tc:
+                            log.debug("T({}) = {}".format(
+                                len(ta_tb_tc), hexlify(ta_tb_tc).decode()))
+                        did_supported = tc is None or bool(tc & 0x02)
+                        cmd_with_did = bool(cmd[0] & 0x08)
+                        if (((cmd_with_did and did_supported and cmd[1] == did)
+                             or (did == 0 and not cmd_with_did))):
+                            if cmd[0] in (0xC2, 0xCA):
+                                log.debug("rcvd S(DESELECT) %s",
+                                          hexlify(cmd).decode())
+                                tg_comm_rf_args['transmit_data'] = cmd
+                                log.debug("send S(DESELECT) %s",
+                                          hexlify(cmd).decode())
+                                rats_cmd = rats_res = None
+                            else:
+                                log.debug("rcvd TT4_CMD %s",
+                                          hexlify(cmd).decode())
+                                self.chipset.tg_set_protocol(rf_off_error=True)
+                                return nfc.clf.LocalTarget(
+                                    "106A", sens_res=nfca_params[0:2],
+                                    sdd_res=b'\x08'+nfca_params[2:5],
+                                    sel_res=nfca_params[5:6], tt4_cmd=cmd,
+                                    rats_cmd=rats_cmd, rats_res=rats_res)
+                        else:
+                            log.debug("skip TT4_CMD %s (DID)",
+                                      hexlify(cmd).decode())
+                    else:
+                        log.debug("not a 106A TT4 command")
+                finally:
+                    recv_timeout = int(1000 * (time_to_return - time.time()))
+                    tg_comm_rf_args['recv_timeout'] = recv_timeout
+
+        if target.sel_res[0] & 0x60 == 0x00:
+            return listen_tta_tt2()
+        if target.sel_res[0] & 0x20 == 0x20:
+            return listen_tta_tt4()
+
+        reason = "sel_res does not indicate any tag target support"
+        raise nfc.clf.UnsupportedTargetError(reason)
+
+    def listen_ttb(self, target, timeout):
+        """Listen as Type B Target is not supported."""
+        message = "{device} does not support listen as Type A Target"
+        raise nfc.clf.UnsupportedTargetError(message.format(device=self))
+
+    def listen_ttf(self, target, timeout):
+        """Listen as Type F Target is supported for either 212 or 424 kbps."""
+        if target.brty not in ('212F', '424F'):
+            info = "unsupported target bitrate: %r" % target.brty
+            raise nfc.clf.UnsupportedTargetError(info)
+
+        if target.sensf_res is None:
+            raise ValueError("sensf_res is required")
+        if len(target.sensf_res) != 19:
+            raise ValueError("sensf_res must be 19 byte")
+
+        self.chipset.tg_set_rf(target.brty)
+        self.chipset.tg_set_protocol(self.chipset.tg_set_protocol_defaults)
+        self.chipset.tg_set_protocol(rf_off_error=False)
+
+        recv_timeout = min(int(1000 * timeout), 0xFFFF)
+        time_to_return = time.time() + timeout
+        transmit_data = sensf_req = sensf_res = None
+
+        while recv_timeout > 0:
+            if transmit_data:
+                log.debug("%s send %s", target.brty,
+                          hexlify(transmit_data).decode())
+            log.debug("%s wait recv %d ms", target.brty, recv_timeout)
+            try:
+                data = self.chipset.tg_comm_rf(recv_timeout=recv_timeout,
+                                               transmit_data=transmit_data)
+            except CommunicationError as error:
+                log.debug(error)
+                continue
+            finally:
+                recv_timeout = int((time_to_return - time.time()) * 1E3)
+                transmit_data = None
+
+            assert target.brty == ('106A', '212F', '424F')[data[0]-11]
+            log.debug("%s rcvd %s", target.brty,
+                      hexlify(memoryview(data)[7:]).decode())
+
+            if len(data) > 7 and len(data)-7 == data[7]:
+                if sensf_req and data[9:17] == target.sensf_res[1:9]:
+                    self.chipset.tg_set_protocol(rf_off_error=True)
+                    target = nfc.clf.LocalTarget(target.brty)
+                    target.sensf_req = sensf_req
+                    target.sensf_res = sensf_res
+                    target.tt3_cmd = data[8:]
+                    return target
+
+            if len(data) == 13 and data[7] == 6 and data[8] == 0:
+                (sensf_req, sensf_res) = (data[8:], target.sensf_res[:])
+                if (((sensf_req[1] == 255 or sensf_req[1] == sensf_res[17]) and
+                     (sensf_req[2] == 255 or sensf_req[2] == sensf_res[18]))):
+                    transmit_data = sensf_res[0:17]
+                    if sensf_req[3] == 1:
+                        transmit_data += sensf_res[17:19]
+                    if sensf_req[3] == 2:
+                        transmit_data += b"\x00"
+                        transmit_data += bytearray(
+                                [1 << (target.brty == "424F")])
+                    transmit_data = bytearray([len(transmit_data)+1]) \
+                        + transmit_data
+
+    def listen_dep(self, target, timeout):
+        log.debug("listen_dep for {0:.3f} sec".format(timeout))
+
+        if not target.sens_res or len(target.sens_res) != 2:
+            raise ValueError("sens_res is required and must be 2 byte")
+        if not target.sel_res or len(target.sel_res) != 1:
+            raise ValueError("sel_res is required and must be 1 byte")
+        if not target.sdd_res or len(target.sdd_res) != 4:
+            raise ValueError("sdd_res is required and must be 4 byte")
+        if not target.sensf_res or len(target.sensf_res) < 19:
+            raise ValueError("sensf_res is required and must be 19 byte")
+        if not target.atr_res or len(target.atr_res) < 17:
+            raise ValueError("atr_res is required and must be >= 17 byte")
+
+        nfca_params = target.sens_res + target.sdd_res[1:4] + target.sel_res
+        nfcf_params = target.sensf_res[1:19]
+        log.debug("nfca_params %s", hexlify(nfca_params).decode())
+        log.debug("nfcf_params %s", hexlify(nfcf_params).decode())
+
+        self.chipset.tg_set_rf("106A")
+        self.chipset.tg_set_protocol(self.chipset.tg_set_protocol_defaults)
+        self.chipset.tg_set_protocol(rf_off_error=False)
+
+        tg_comm_rf_args = {'mdaa': True}
+        tg_comm_rf_args['nfca_params'] = nfca_params
+        tg_comm_rf_args['nfcf_params'] = nfcf_params
+
+        recv_timeout = min(int(1000 * timeout), 0xFFFF)
+        time_to_return = time.time() + timeout
+
+        while recv_timeout > 0:
+            tg_comm_rf_args['recv_timeout'] = recv_timeout
+            log.debug("wait %d ms for activation", recv_timeout)
+            try:
+                data = self.chipset.tg_comm_rf(**tg_comm_rf_args)
+            except CommunicationError as error:
+                if error != "RECEIVE_TIMEOUT_ERROR":
+                    log.warning(error)
+            else:
+                brty = ('106A', '212F', '424F')[data[0]-11]
+                log.debug("%s %s", brty, hexlify(data).decode())
+                if data[2] & 0x03 == 3:
+                    data = data[7:]
+                    break
+                else:
+                    log.debug("not a passive mode activation")
+            recv_timeout = int(1000 * (time_to_return - time.time()))
+        else:
+            return None
+
+        # further tg_comm_rf commands return RF_OFF_ERROR when field is gone
+        self.chipset.tg_set_protocol(rf_off_error=True)
+
+        if brty == "106A" and len(data) > 1 and data[0] != 0xF0:
+            # We received a Type A card activation, probably because
+            # sel_res has indicated Type 2 or Type 4A Tag support.
+            target = nfc.clf.LocalTarget("106A", tt2_cmd=data[:])
+            target.sens_res = nfca_params[0:2]
+            target.sdd_res = b'\x08' + nfca_params[2:5]
+            target.sel_res = nfca_params[5:6]
+            return target
+
+        def verify_frame(brty, data, cmd_set):
+            offset = 1 if brty == "106A" else 0
+            try:
+                if brty == "106A" and data[0] != 0xF0:
+                    log.warning("rcvd frame has invalid start byte")
+                elif data[offset] != len(data) - offset:
+                    log.warning("rcvd frame has incorrect length byte")
+                elif data[offset+1] != 0xD4:
+                    log.warning("rcvd frame command byte 1 is not D4h")
+                elif data[offset+2] not in cmd_set:
+                    log.warning(
+                            "rcvd frame command byte 2 not in %r" % cmd_set)
+                else:
+                    return data[offset+1:]
+            except (IndexError):
+                log.warning("rcvd frame with less than header size")
+
+        def send_res_recv_req(brty, data, timeout):
+            if data:
+                data = (b"", b"\xF0")[brty == "106A"] + \
+                       bytes([len(data)+1]) + data
+            args = {'transmit_data': data, 'recv_timeout': timeout}
+            data = self.chipset.tg_comm_rf(**args)[7:]
+            if timeout > 0:
+                return verify_frame(brty, data, cmd_set=[0, 4, 6, 8, 10])
+
+        activation_params = nfca_params if brty == '106A' else nfcf_params
+        data = verify_frame(brty, data, cmd_set=[0])
+
+        while data and data[1] == 0:
+            try:
+                (atr_req, atr_res) = (data[:], target.atr_res)
+                log.debug("%s rcvd ATR_REQ %s",
+                          brty, hexlify(atr_req).decode())
+                if 16 <= len(atr_req) <= 64:
+                    log.debug("%s send ATR_RES %s", brty,
+                              hexlify(atr_res).decode())
+                    data = send_res_recv_req(brty, atr_res, 1000)
+                else:
+                    log.warning("ATR_REQ must be 16 to 64 byte")
+                    data = None
+            except (CommunicationError) as error:
+                log.warning(str(error))
+                data = None
+
+        def send_dsl_res(brty, data):
+            dsl_res = b"\xD5\x09" + data[2:3]
+            log.debug("%s send DSL_RES %s", brty, hexlify(dsl_res).decode())
+            send_res_recv_req(brty, dsl_res, 0)
+
+        def send_rls_res(brty, data):
+            rls_res = b"\xD5\x0B" + data[2:3]
+            log.debug("%s send RLS_RES %s", brty, hexlify(rls_res).decode())
+            send_res_recv_req(brty, rls_res, 0)
+
+        def send_psl_res(brty, data):
+            (dsi, dri) = (data[3] >> 3 & 7, data[3] & 7)
+            if dsi != dri:
+                log.error("PSL_REQ DSI != DRI is not supported")
+                raise CommunicationError(b'\0\0\0\0')
+            (psl_req, psl_res) = (data[:], b"\xD5\x05" + data[2:3])
+            log.debug("%s send PSL_RES %s", brty, hexlify(psl_res).decode())
+            send_res_recv_req(brty, psl_res, 0)
+            brty = ('106A', '212F', '424F')[dsi]
+            self.chipset.tg_set_rf(brty)
+            return brty, psl_req, psl_res
+
+        psl_req = None
+        while data and data[1] in (4, 6, 8, 10):
+            did = atr_req[12] if atr_req[12] > 0 else None
+            cmd = {4: "PSL", 6: "DEP", 8: "DSL", 10: "RLS"}.get(data[1], '???')
+            log.debug("%s rcvd %s_REQ %s", brty, cmd, hexlify(data).decode())
+            try:
+                if cmd == "DEP":
+                    if did == (data[3] if data[2] >> 2 & 1 else None):
+                        target = nfc.clf.LocalTarget(brty, dep_req=data)
+                        target.atr_req = atr_req
+                        if psl_req:
+                            target.psl_req = psl_req
+                        if activation_params == nfca_params:
+                            target.sens_res = nfca_params[0:2]
+                            target.sdd_res = b'\x08' + nfca_params[2:5]
+                            target.sel_res = nfca_params[5:6]
+                        else:
+                            target.sensf_res = b"\x01" + nfcf_params
+                        return target
+
+                elif cmd == "DSL":
+                    if did == (data[2] if len(data) > 2 else None):
+                        return send_dsl_res(brty, data)
+
+                elif cmd == "RLS":
+                    if did == (data[2] if len(data) > 2 else None):
+                        return send_rls_res(brty, data)
+
+                elif cmd == "PSL":  # pragma: no branch
+                    if did == (data[2] if data[2] > 0 else None):
+                        brty, psl_req, psl_res = send_psl_res(brty, data)
+
+                log.debug("%s wait recv 1000 ms", brty)
+                data = send_res_recv_req(brty, None, 1000)
+
+            except (CommunicationError) as error:
+                log.warning(str(error))
+                return None
+
+    def get_max_send_data_size(self, target):
+        return 290
+
+    def get_max_recv_data_size(self, target):
+        return 290
+
+    def send_cmd_recv_rsp(self, target, data, timeout):
+        if timeout:
+            timeout_msec = max(min(int(timeout * 1000), 0xFFFF), 1)
+        else:
+            timeout_msec = 0
+        self.chipset.in_set_rf(target.brty_send, target.brty_recv)
+        self.chipset.in_set_protocol(self.chipset.in_set_protocol_defaults)
+        in_set_protocol_settings = {}
+        if target.brty_send.endswith('A'):
+            in_set_protocol_settings['add_parity'] = 1
+            in_set_protocol_settings['check_parity'] = 1
+        if target.brty_send.endswith('B'):
+            in_set_protocol_settings['initial_guard_time'] = 20
+            in_set_protocol_settings['add_sof'] = 1
+            in_set_protocol_settings['check_sof'] = 1
+            in_set_protocol_settings['add_eof'] = 1
+            in_set_protocol_settings['check_eof'] = 1
+        try:
+            if ((target.brty == '106A' and target.sel_res and
+                 target.sel_res[0] & 0x60 == 0x00)):
+                # Driver must check TT2 CRC to get ACK/NAK
+                in_set_protocol_settings['check_crc'] = 0
+                self.chipset.in_set_protocol(**in_set_protocol_settings)
+                return self._tt2_send_cmd_recv_rsp(data, timeout_msec)
+            else:
+                self.chipset.in_set_protocol(**in_set_protocol_settings)
+                return self.chipset.in_comm_rf(data, timeout_msec)
+        except CommunicationError as error:
+            log.debug(error)
+            if error == "RECEIVE_TIMEOUT_ERROR":
+                raise nfc.clf.TimeoutError
+            raise nfc.clf.TransmissionError
+
+    def _tt2_send_cmd_recv_rsp(self, data, timeout_msec):
+        # The Type2Tag implementation needs to receive the Mifare
+        # ACK/NAK responses but the chipset reports them as crc error
+        # (indistinguishable from a real crc error). We thus had to
+        # switch off the crc check and do it here.
+        data = self.chipset.in_comm_rf(data, timeout_msec)
+        if len(data) > 2 and self.check_crc_a(data) is False:
+            raise nfc.clf.TransmissionError("crc_a check error")
+        return data[:-2] if len(data) > 2 else data
+
+    def send_rsp_recv_cmd(self, target, data, timeout):
+        assert timeout is None or timeout >= 0
+        kwargs = {
+            'guard_time': 500,
+            'transmit_data': data,
+            'recv_timeout': 0xFFFF if timeout is None else int(timeout*1E3),
+        }
+        try:
+            data = self.chipset.tg_comm_rf(**kwargs)
+            return data[7:] if data else None
+        except CommunicationError as error:
+            log.debug(error)
+            if error == "RF_OFF_ERROR":
+                raise nfc.clf.BrokenLinkError(str(error))
+            if error == "RECEIVE_TIMEOUT_ERROR":
+                raise nfc.clf.TimeoutError(str(error))
+            raise nfc.clf.TransmissionError(str(error))
+
+
+def init(transport):
+    chipset = Chipset(transport, logger=log)
+    device = Device(chipset, logger=log)
+    device._vendor_name = transport.manufacturer_name
+    device._device_name = transport.product_name
+    return device

src/lib/nfc/clf/rcs956.py

@@ -0,0 +1,376 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""Driver for contacless devices based on the Sony RC-S956
+chipset. Products known to use this chipset are the PaSoRi RC-S330,
+RC-S360, and RC-S370. The RC-S956 connects to the host as a native USB
+device.
+
+The RC-S956 has the same hardware architecture as the NXP PN53x
+family, i.e. it has a PN512 Contactless Interface Unit (CIU) coupled
+with a 80C51 microcontroller and uses the same frame structure for
+host communication and mostly the same commands. However, the firmware
+that runs on the 80C51 is different and the most notable difference is
+a much stricter state machine. The state machine restricts allowed
+commands to certain modes. While direct access to the CIU registers is
+possible, some of the things that can be done with a PN53x are
+unfortunately prevented by the stricter state machine.
+
+==========  =======  ============
+function    support  remarks
+==========  =======  ============
+sense_tta   yes      Only Type 1 Tags up to 128 byte (Topaz-96)
+sense_ttb   yes      ATTRIB by firmware voided with S(DESELECT)
+sense_ttf   yes
+sense_dep   yes
+listen_tta  yes      Only DEP and Type 2 Target
+listen_ttb  no
+listen_ttf  no
+listen_dep  yes      Only passive communication mode
+==========  =======  ============
+
+"""
+import nfc.clf
+from . import pn53x
+
+import time
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Chipset(pn53x.Chipset):
+    CMD = {
+        0x00: "Diagnose",
+        0x02: "GetFirmwareVersion",
+        0x04: "GetGeneralStatus",
+        0x06: "ReadRegister",
+        0x08: "WriteRegister",
+        0x0C: "ReadGPIO",
+        0x10: "SetSerialBaudrate",
+        0x12: "SetParameters",
+        0x16: "PowerDown",
+        0x32: "RFConfiguration",
+        0x58: "RFRegulationTest",
+        0x18: "ResetMode",
+        0x1C: "ControlLED",
+        0x56: "InJumpForDEP",
+        0x46: "InJumpForPSL",
+        0x4A: "InListPassiveTarget",
+        0x50: "InATR",
+        0x4E: "InPSL",
+        0x40: "InDataExchange",
+        0x42: "InCommunicateThru",
+        0x44: "InDeselect",
+        0x52: "InRelease",
+        0x54: "InSelect",
+        0x8C: "TgInitTarget",
+        0x92: "TgSetGeneralBytes",
+        0x86: "TgGetDEPData",
+        0x8E: "TgSetDEPData",
+        0x94: "TgSetMetaDEPData",
+        0x88: "TgGetInitiatorCommand",
+        0x90: "TgResponseToInitiator",
+        0x8A: "TgGetTargetStatus",
+        0xA0: "CommunicateThruEX",
+    }
+    ERR = {
+        0x01: "Time out, the Target has not answered",
+        0x02: "Checksum error during RF communication",
+        0x03: "Parity error during RF communication",
+        0x04: "Incorrect collision bit position in TargetID during SDD",
+        0x07: "Overflow detected by the hardware during RF communication",
+        0x0A: "RF field not activated in time by active mode peer",
+        0x0B: "Protocol error during RF communication",
+        0x0C: "More than 260 bytes payload received in ISO-DEP chaining",
+        0x0D: "Overheated - antenna drivers deactivated",
+        0x10: "Size of RF response packet during SDD was more than 4 bytes",
+        0x13: "Format error during RF communication or retry count exceeded",
+        0x14: "Authentication A or B failed for Type-A ISO target",
+        0x17: "Unmatched block number in R(ACK) from ISO Type A or B card",
+        0x23: "Invalid BCC value from ISO Type A card during anticollision",
+        0x25: "TgGetDEPData or TgSetDEPData executed at wrong time",
+        0x26: "PowerDown command received while USB interface being used",
+        0x27: "Abnormal Tg parameter in the host command packet",
+        0x29: "Release from the initiator in operation as DEPTarget",
+        0x2A: "PUPI information in ATQB response differs from initial value",
+        0x2B: "Failure to select a deselected target",
+        0x2F: "Already deselected by the initiator in operation as DEPTarget",
+        0x31: "Initiator RF-OFF state detected while operating as Target",
+        0x32: "Buffer overflow detected by firmware during RF communication",
+        0x34: "DEP_REQ(NACK) received but DEP_RES(INF) was never returned",
+        0x35: "The received data exceeds LEN in the RF packet",
+        0x7f: "Invalid command syntax - received error frame",
+        0xfe: "A register write operation failed",
+        0xff: "No data received from executing chip command",
+    }
+
+    host_command_frame_max_size = 265
+    in_list_passive_target_max_target = 1
+    in_list_passive_target_brty_range = (0, 1, 2, 3, 4)
+
+    def diagnose(self, test, test_data=None):
+        if test == "line":
+            size = self.host_command_frame_max_size - 3
+            data = bytearray([x & 0xFF for x in range(size)])
+            return self.command(0x00, b"\x00" + data, timeout=1.0) == data
+        return super(Chipset, self).diagnose(test, test_data)
+
+    def _read_register(self, data):
+        # Max 64 registers can be read from RCS956
+        assert len(data) <= 128
+        return self.command(0x06, data, timeout=0.25)
+
+    def _write_register(self, data):
+        # Max 64 registers can be written to RCS956
+        assert len(data) <= 192
+        status = self.command(0x08, data, timeout=0.25)
+        if sum(status) != 0:
+            self.chipset_error(0xfe)
+
+    def reset_mode(self):
+        """Send a Reset command to set the operation mode to 0."""
+        self.command(0x18, b"\x01", timeout=0.1)
+        self.transport.write(Chipset.ACK)
+        time.sleep(0.010)
+
+    def tg_init_target(self, mode, mifare_params, felica_params,
+                       nfcid3t, gt, timeout):
+        assert type(mode) is int and mode & 0b11111101 == 0
+        assert len(mifare_params) == 6
+        assert len(felica_params) == 18
+        assert len(nfcid3t) == 10
+
+        data = bytearray([mode]) + mifare_params + felica_params + nfcid3t + gt
+        return self.command(0x8c, data, timeout)
+
+
+class Device(pn53x.Device):
+    # Device driver for Sony RC-S956 based contactless devices.
+
+    def __init__(self, chipset, logger):
+        assert isinstance(chipset, Chipset)
+        # Reset the RCS956 state machine to Mode 0. We may have left
+        # it in some other mode when an error has occured.
+        chipset.reset_mode()
+
+        super(Device, self).__init__(chipset, logger)
+
+        ic, ver, rev, support = self.chipset.get_firmware_version()
+        self._chipset_name = "RCS956v{0:x}.{1:x}".format(ver, rev)
+        self.log.debug("chipset is a {0}".format(self._chipset_name))
+
+        self.mute()
+        # Set timeout for PSL_RES, ATR_RES, InDataExchange/InCommunicateThru
+        self.chipset.rf_configuration(0x02, b"\x0B\x0B\x0A")
+        self.chipset.rf_configuration(0x04, b"\x00")
+        self.chipset.rf_configuration(0x05, b"\x00\x00\x01")
+
+        self.log.debug("write rf settings for 106A")
+        data = bytearray.fromhex("5A F4 3F 11 4D 85 61 6F 26 62 87")
+        self.chipset.rf_configuration(0x0A, data)
+
+        self.chipset.set_parameters(0b00001000)
+        self.chipset.reset_mode()
+
+        # Set the RFCfg value for RAM-07. RF settings in RAM-07 are
+        # used for initial target state. During power-up RAM-07 is
+        # loaded from EEPROM-07 and the RFCfg value 0xFD stored in
+        # EEPROM-07 for RC-S330/360 prevents passive mode activation
+        # at 106A. It works with the RFCfg value 0x59 stored in ROM-07
+        # (Neither value makes it work in active mode).
+        self.chipset.write_register(0x0328, 0x59)
+
+    def close(self):
+        self.mute()
+        super(Device, self).close()
+
+    def mute(self):
+        self.chipset.reset_mode()
+        super(Device, self).mute()
+
+    def sense_tta(self, target):
+        """Activate the RF field and probe for a Type A Target.
+
+        The RC-S956 can discover all Type A Targets (Type 1 Tag, Type
+        2 Tag, and Type 4A Tag) at 106 kbps. Due to firmware
+        restrictions it is not possible to read a Type 1 Tag with
+        dynamic memory layout (more than 128 byte memory).
+
+        """
+        target = super(Device, self).sense_tta(target)
+        if target and target.rid_res:
+            # This is a TT1 tag. Unfortunately we can only read it if
+            # it is a static memory tag. The RCS956 has implemented
+            # the same wrong command codes as PN531/2/3 and directly
+            # programming the CIU does not work.
+            if target.rid_res[0] >> 4 == 1 and target.rid_res[0] & 15 != 1:
+                msg = "The {device} can not read this Type 1 Tag."
+                self.log.warning(msg.format(device=self))
+                return None
+        return target
+
+    def sense_ttb(self, target):
+        """Activate the RF field and probe for a Type B Target.
+
+        The RC-S956 can discover Type B Targets (Type 4B Tag) at 106
+        kbps. For a Type 4B Tag the firmware automatically sends an
+        ATTRIB command that configures the use of DID and 64 byte
+        maximum frame size. The driver reverts this configuration with
+        a DESELECT and WUPB command to return the target prepared for
+        activation (which nfcpy does in the tag activation code).
+
+        """
+        return super(Device, self).sense_ttb(target, did=b'\x01')
+
+    def sense_ttf(self, target):
+        """Activate the RF field and probe for a Type F Target.
+
+        """
+        return super(Device, self).sense_ttf(target)
+
+    def sense_dep(self, target):
+        """Search for a DEP Target in active or passive communication mode.
+
+        """
+        # Set timeout for PSL_RES and ATR_RES
+        self.chipset.rf_configuration(0x02, b"\x0B\x0B\x0A")
+        return super(Device, self).sense_dep(target)
+
+    def listen_tta(self, target, timeout):
+        """Listen *timeout* seconds for a Type A activation at 106 kbps. The
+        ``sens_res``, ``sdd_res``, and ``sel_res`` response data must
+        be provided and ``sdd_res`` must be a 4 byte UID that starts
+        with ``08h``. Depending on ``sel_res`` an activation may
+        return a target with ``tt2_cmd`` or ``atr_req`` attribute. A
+        Type 4A Tag activation is not supported.
+
+        """
+        if target.sel_res and target.sel_res[0] & 0x20:
+            info = "{device} does not support listen as Type 4A Target"
+            raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+        return super(Device, self).listen_tta(target, timeout)
+
+    def listen_ttb(self, target, timeout):
+        """Listen as Type B Target is not supported."""
+        info = "{device} does not support listen as Type B Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_ttf(self, target, timeout):
+        """Listen as Type F Target is not supported."""
+        info = "{device} does not support listen as Type F Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_dep(self, target, timeout):
+        """Listen *timeout* seconds to become initialized as a DEP Target.
+
+        The RC-S956 can be set to listen as a DEP Target for passive
+        communication mode. Target active communication mode is
+        disabled by the driver due to performance issues. It is also
+        not possible to fully control the ATR_RES response, only the
+        response waiting time (TO byte of ATR_RES) and the general
+        bytes can be set by the driver. Because the TO value must be
+        set before calling the hardware listen function, it can not be
+        different for the Type A of Type F passive initalization (the
+        driver uses the higher value if they are different).
+
+        """
+        # The RCS956 internal state machine must be in Mode 0 before
+        # we enter the listen phase. Also the RFConfiguration command
+        # for setting the TO parameter won't work in any other mode.
+        self.chipset.reset_mode()
+
+        # Set the WaitForSelected bit in CIU_FelNFC2 register to
+        # prevent active mode activation. Target active mode is not
+        # really working with this device.
+        self.chipset.write_register("CIU_FelNFC2", 0x80)
+
+        # We can not send ATR_RES as as a regular response but must
+        # use TgSetGeneralBytes to advance the chipset state machine
+        # to mode 3. Thus the ATR_RES is mostly determined by the
+        # firmware, we can only control the TO parameter for RWT, but
+        # must do it before the actual listen.
+        to = target.atr_res[15] & 0x0F
+        self.chipset.rf_configuration(0x82, bytearray([to, 2, to]))
+
+        # Disable automatic ATR_RES transmission. This must be done
+        # all again because the chipset reactivates the setting after
+        # ATR_RES was once send in TgSetGeneralBytes.
+        self.chipset.set_parameters(0b00001000)
+
+        # Now we can use the generic pn53x implementation
+        return super(Device, self).listen_dep(target, timeout)
+
+    def _init_as_target(self, mode, tta_params, ttf_params, timeout):
+        nfcid3t = ttf_params[0:8] + b"\x00\x00"
+        args = (mode & 0xFE, tta_params, ttf_params, nfcid3t, b'', timeout)
+        return self.chipset.tg_init_target(*args)
+
+    def _send_atr_response(self, atr_res, timeout):
+        # Before ATR_RES the device is in Mode 2 which does not allow
+        # the use of TgResponseToInitiator. To send the ATR_RES we
+        # must use TgSetGeneralBytes and can control only the general
+        # bytes and TO which we've set in _listen_dep(). We now copy
+        # the DID value from atr_req to atr_res but this will likely
+        # have no effect on the actual response. The hope is that the
+        # firmware will do the same when sending ATR_RES and we tell
+        # the truth to the caller.
+        self.log.debug("calling TgSetGeneralBytes to send ATR_RES")
+        self.chipset.tg_set_general_bytes(atr_res[17:])
+        return self.chipset.tg_get_initiator_command(timeout)
+
+    def _tt1_send_cmd_recv_rsp(self, data, timeout):
+        # Special handling for Tag Type 1 (Jewel/Topaz) card commands.
+
+        if data[0] in (0x00, 0x01, 0x1A, 0x53, 0x72):
+            # RALL, READ, WRITE-NE, WRITE-E, RID are properly
+            # implemented by firmware.
+            return self.chipset.in_data_exchange(data, timeout)[0]
+
+        # The other commands can not be executed. The workaround found
+        # for PN531, PN532 and PN533 fails with RCS956. While it is
+        # possible to properly send a TT1 command and the tag answers
+        # as expected, there is no way to get the response data from
+        # the CIU FIFO. For whatever reason the FIFO is empty, maybe
+        # the firmware constantly polls for new data and just removes
+        # it. That the response data was received can be guessed from
+        # the fact that the CIU Control register shows has the
+        # RxLastBits field set to exactly the correct number of valid
+        # bits in the last byte (when parity check is disabled,
+        # i.e. the FIFO contains one more bit for each received byte.
+        self.log.debug("tt1 command can not be send with this hardware ")
+        raise nfc.clf.TransmissionError("tt1 command can not be send")
+
+
+def init(transport):
+    # Write ack to see if we can talk to the device. This raises
+    # IOError(EACCES) if it's claimed by some other process.
+    transport.write(Chipset.ACK)
+
+    chipset = Chipset(transport, logger=log)
+    device = Device(chipset, logger=log)
+
+    device._vendor_name = transport.manufacturer_name
+    device._device_name = transport.product_name
+    if device._device_name is None:
+        device._device_name = "RC-S330"
+
+    return device

src/lib/nfc/clf/transport.py

@@ -0,0 +1,345 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2012, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+#
+# Transport layer for host to reader communication.
+#
+import os
+import re
+import errno
+from binascii import hexlify
+
+if not os.getenv("READTHEDOCS"):  # pragma: no cover
+    try:
+        import usb1 as libusb
+    except ImportError:  # pragma: no cover
+        raise ImportError("missing usb1 module, try 'pip install libusb1'")
+
+try:
+    import serial
+    import serial.tools.list_ports
+except ImportError:  # pragma: no cover
+    raise ImportError("missing serial module, try 'pip install pyserial'")
+
+try:
+    import termios
+except ImportError:  # pragma: no cover
+    assert os.name != 'posix'
+
+import logging
+log = logging.getLogger(__name__)
+
+PATH = re.compile(r'^([a-z]+)(?::|)([a-zA-Z0-9-]+|)(?::|)([a-zA-Z0-9]+|)$')
+
+
+class TTY(object):
+    TYPE = "TTY"
+
+    @classmethod
+    def find(cls, path):
+        if not (path.startswith("tty") or path.startswith("com")):
+            return
+
+        match = PATH.match(path)
+
+        if match and match.group(1) == "tty":
+            if re.match(r'^(S|ACM|AMA|USB)\d+$', match.group(2)):
+                TTYS = re.compile(r'^tty{}$'.format(match.group(2)))
+                glob = False
+            elif re.match(r'^(S|ACM|AMA|USB)$', match.group(2)):
+                TTYS = re.compile(r'^tty{}\d+$'.format(match.group(2)))
+                glob = True
+            elif re.match(r'^usbserial-\w+$', match.group(2)):
+                TTYS = re.compile(r'^cu\.{}$'.format(match.group(2)))
+                glob = False
+            elif re.match(r'^usbserial$', match.group(2)):
+                TTYS = re.compile(r'^cu\.usbserial-.*$')
+                glob = True
+            elif re.match(r'^.+$', match.group(2)):
+                TTYS = re.compile(r'^{}$'.format(match.group(2)))
+                glob = False
+            else:
+                TTYS = re.compile(r'^(tty(S|ACM|AMA|USB)\d+|cu\.usbserial.*)$')
+                glob = True
+
+            log.debug(TTYS.pattern)
+            ttys = [fn for fn in os.listdir('/dev') if TTYS.match(fn)]
+
+            if len(ttys) > 0:
+                # Sort ttys with custom function to correctly order numbers.
+                ttys.sort(key=lambda item: (len(item), item))
+                log.debug('check: ' + ' '.join('/dev/' + tty for tty in ttys))
+
+                # Eliminate tty nodes that are not physically present or
+                # inaccessible by the current user. Propagate IOError when
+                # path designated exactly one device, otherwise just log.
+                for i, tty in enumerate(ttys):
+                    try:
+                        termios.tcgetattr(open('/dev/%s' % tty))
+                        ttys[i] = '/dev/%s' % tty
+                    except termios.error:
+                        pass
+                    except IOError as error:
+                        log.debug(error)
+                        if not glob:
+                            raise error
+
+                ttys = [tty for tty in ttys if tty.startswith('/dev/')]
+                log.debug('avail: %s', ' '.join([tty for tty in ttys]))
+                return ttys, match.group(3), glob
+
+        if match and match.group(1) == "com":
+            if re.match(r'^COM\d+$', match.group(2)):
+                return [match.group(2)], match.group(3), False
+            if re.match(r'^\d+$', match.group(2)):
+                return ["COM" + match.group(2)], match.group(3), False
+            if re.match(r'^$', match.group(2)):
+                ports = [p[0] for p in serial.tools.list_ports.comports()]
+                log.debug('serial ports: %s', ' '.join(ports))
+                return ports, match.group(3), True
+            log.error("invalid port in 'com' path: %r", match.group(2))
+
+    @property
+    def manufacturer_name(self):
+        return None
+
+    @property
+    def product_name(self):
+        return None
+
+    def __init__(self, port=None):
+        self.tty = None
+        self.open(port)
+
+    def open(self, port, baudrate=115200):
+        self.close()
+        self.tty = serial.Serial(port, baudrate, timeout=0.05)
+
+    @property
+    def port(self):
+        return self.tty.port if self.tty else ''
+
+    @property
+    def baudrate(self):
+        return self.tty.baudrate if self.tty else 0
+
+    @baudrate.setter
+    def baudrate(self, value):
+        if self.tty:
+            self.tty.baudrate = value
+
+    def read(self, timeout):
+        if self.tty is not None:
+            self.tty.timeout = max(timeout/1E3, 0.05)
+            frame = bytearray(self.tty.read(6))
+            if frame is None or len(frame) == 0:
+                raise IOError(errno.ETIMEDOUT, os.strerror(errno.ETIMEDOUT))
+            if frame.startswith(b"\x00\x00\xff\x00\xff\x00"):
+                log.log(logging.DEBUG-1, "<<< %s", hexlify(frame).decode())
+                return frame
+            LEN = frame[3]
+            if LEN == 0xFF:
+                frame += self.tty.read(3)
+                LEN = frame[5] << 8 | frame[6]
+            frame += self.tty.read(LEN + 1)
+            log.log(logging.DEBUG-1, "<<< %s", hexlify(frame).decode())
+            return frame
+
+    def write(self, frame):
+        if self.tty is not None:
+            log.log(logging.DEBUG-1, ">>> %s", hexlify(frame).decode())
+            self.tty.flushInput()
+            try:
+                self.tty.write(frame)
+            except serial.SerialTimeoutException:
+                raise IOError(errno.EIO, os.strerror(errno.EIO))
+
+    def close(self):
+        if self.tty is not None:
+            self.tty.flushOutput()
+            self.tty.close()
+            self.tty = None
+
+
+class USB(object):
+    TYPE = "USB"
+
+    @classmethod
+    def find(cls, path):
+        if not path.startswith("usb"):
+            return
+
+        log.debug("using libusb-{0}.{1}.{2}".format(*libusb.getVersion()[0:3]))
+
+        usb_or_none = re.compile(r'^(usb|)$')
+        usb_vid_pid = re.compile(r'^usb(:[0-9a-fA-F]{4})(:[0-9a-fA-F]{4})?$')
+        usb_bus_dev = re.compile(r'^usb(:[0-9]{1,3})(:[0-9]{1,3})?$')
+        match = None
+
+        for regex in (usb_vid_pid, usb_bus_dev, usb_or_none):
+            m = regex.match(path)
+            if m is not None:
+                log.debug("path matches {0!r}".format(regex.pattern))
+                if regex is usb_vid_pid:
+                    match = [int(s.strip(':'), 16) for s in m.groups() if s]
+                    match = dict(zip(['vid', 'pid'], match))
+                if regex is usb_bus_dev:
+                    match = [int(s.strip(':'), 10) for s in m.groups() if s]
+                    match = dict(zip(['bus', 'adr'], match))
+                if regex is usb_or_none:
+                    match = dict()
+                break
+        else:
+            return None
+
+        with libusb.USBContext() as context:
+            devices = context.getDeviceList(skip_on_error=True)
+            vid, pid = match.get('vid'), match.get('pid')
+            bus, dev = match.get('bus'), match.get('adr')
+            if vid is not None:
+                devices = [d for d in devices if d.getVendorID() == vid]
+            if pid is not None:
+                devices = [d for d in devices if d.getProductID() == pid]
+            if bus is not None:
+                devices = [d for d in devices if d.getBusNumber() == bus]
+            if dev is not None:
+                devices = [d for d in devices if d.getDeviceAddress() == dev]
+            return [(d.getVendorID(), d.getProductID(), d.getBusNumber(),
+                     d.getDeviceAddress()) for d in devices]
+
+    def __init__(self, usb_bus, dev_adr):
+        self.context = libusb.USBContext()
+        self.open(usb_bus, dev_adr)
+
+    def __del__(self):
+        self.close()
+        if self.context:  # pragma: no branch
+            self.context.exit()
+
+    def open(self, usb_bus, dev_adr):
+        self.usb_dev = None
+        self.usb_out = None
+        self.usb_inp = None
+
+        for dev in self.context.getDeviceList(skip_on_error=True):
+            if ((dev.getBusNumber() == usb_bus and
+                 dev.getDeviceAddress() == dev_adr)):
+                break
+        else:
+            log.error("no device {0} on bus {1}".format(dev_adr, usb_bus))
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+        try:
+            first_setting = next(dev.iterSettings())
+        except StopIteration:
+            log.error("no usb configuration settings, please replug device")
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+        def transfer_type(x):
+            return x & libusb.TRANSFER_TYPE_MASK
+
+        def endpoint_dir(x):
+            return x & libusb.ENDPOINT_DIR_MASK
+
+        for endpoint in first_setting.iterEndpoints():
+            ep_addr = endpoint.getAddress()
+            ep_attr = endpoint.getAttributes()
+            if transfer_type(ep_attr) == libusb.TRANSFER_TYPE_BULK:
+                if endpoint_dir(ep_addr) == libusb.ENDPOINT_IN:
+                    if not self.usb_inp:
+                        self.usb_inp = endpoint
+                if endpoint_dir(ep_addr) == libusb.ENDPOINT_OUT:
+                    if not self.usb_out:
+                        self.usb_out = endpoint
+
+        if not (self.usb_inp and self.usb_out):
+            log.error("no bulk endpoints for read and write")
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+        try:
+            # workaround the PN533's buggy USB implementation
+            self._manufacturer_name = dev.getManufacturer()
+            self._product_name = dev.getProduct()
+        except libusb.USBErrorIO:
+            self._manufacturer_name = None
+            self._product_name = None
+
+        try:
+            self.usb_dev = dev.open()
+            self.usb_dev.claimInterface(0)
+        except libusb.USBErrorAccess:
+            raise IOError(errno.EACCES, os.strerror(errno.EACCES))
+        except libusb.USBErrorBusy:
+            raise IOError(errno.EBUSY, os.strerror(errno.EBUSY))
+        except libusb.USBErrorNoDevice:
+            raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+
+    def close(self):
+        if self.usb_dev:
+            self.usb_dev.close()
+        self.usb_dev = None
+        self.usb_out = None
+        self.usb_inp = None
+
+    @property
+    def manufacturer_name(self):
+        return self._manufacturer_name
+
+    @property
+    def product_name(self):
+        return self._product_name
+
+    def read(self, timeout=0):
+        if self.usb_inp is not None:
+            try:
+                ep_addr = self.usb_inp.getAddress()
+                frame = self.usb_dev.bulkRead(ep_addr, 300, timeout)
+            except libusb.USBErrorTimeout:
+                raise IOError(errno.ETIMEDOUT, os.strerror(errno.ETIMEDOUT))
+            except libusb.USBErrorNoDevice:
+                raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+            except libusb.USBError as error:
+                log.error("%r", error)
+                raise IOError(errno.EIO, os.strerror(errno.EIO))
+
+            if len(frame) == 0:
+                log.error("bulk read returned zero data")
+                raise IOError(errno.EIO, os.strerror(errno.EIO))
+
+            frame = bytearray(frame)
+            log.log(logging.DEBUG-1, "<<< %s", hexlify(frame).decode())
+            return frame
+
+    def write(self, frame, timeout=0):
+        if self.usb_out is not None:
+            log.log(logging.DEBUG-1, ">>> %s", hexlify(frame).decode())
+            try:
+                ep_addr = self.usb_out.getAddress()
+                self.usb_dev.bulkWrite(ep_addr, bytes(frame), timeout)
+                if len(frame) % self.usb_out.getMaxPacketSize() == 0:
+                    self.usb_dev.bulkWrite(ep_addr, b'', timeout)
+            except libusb.USBErrorTimeout:
+                raise IOError(errno.ETIMEDOUT, os.strerror(errno.ETIMEDOUT))
+            except libusb.USBErrorNoDevice:
+                raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
+            except libusb.USBError as error:
+                log.error("%r", error)
+                raise IOError(errno.EIO, os.strerror(errno.EIO))

src/lib/nfc/clf/udp.py

@@ -0,0 +1,577 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2012, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""Driver module for simulated contactless communication over
+UDP/IP. It can be activated with the device path ``udp:<host>:<port>``
+where the optional *host* may be the IP address or name of the node
+where the targeted communication partner is listening on *port*. The
+default values for *host* and *port* are ``localhost:54321``.
+
+The driver implements almost all communication modes, with the current
+exception of active communication mode data exchange protocol.
+
+==========  =======  ============
+function    support  remarks
+==========  =======  ============
+sense_tta   yes
+sense_ttb   yes
+sense_ttf   yes
+sense_dep   no
+listen_tta  yes
+listen_ttb  yes
+listen_ttf  yes
+listen_dep  yes
+==========  =======  ============
+
+"""
+import nfc.clf
+
+import time
+import errno
+import socket
+import select
+import operator
+from functools import reduce
+from binascii import hexlify, unhexlify
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Device(nfc.clf.device.Device):
+    def __init__(self, host, port):
+        host = socket.gethostbyname(host)
+        host, port = socket.getnameinfo((host, port), socket.NI_NUMERICHOST)
+        self.addr = (host, int(port))
+        self._path = "%s:%s" % (host, port)
+        self.socket = None
+        self._create_socket()
+
+    def close(self):
+        self.mute()
+
+    def mute(self):
+        if self.socket:
+            # send RFOFF when socket port != listen port
+            if self.socket.getsockname()[1] != self.addr[1] and self.rcvd_data:
+                self._send_data("RFOFF", b"", self.addr)
+            self.socket.close()
+            self.socket = None
+
+    def sense_tta(self, target):
+        self._create_socket()
+
+        log.debug("sense_tta for %s on %s:%d", target, *self.addr)
+
+        if target.brty not in ("106A", "212A", "424A"):
+            message = "unsupported bitrate {0}".format(target.brty)
+            raise nfc.clf.UnsupportedTargetError(message)
+
+        sens_req = (target.sens_req if target.sens_req else
+                    bytearray.fromhex("26"))
+
+        log.debug("send SENS_REQ %s", hexlify(sens_req).decode())
+        try:
+            self._send_data(target.brty, sens_req, self.addr)
+            brty, sens_res, addr = self._recv_data(1.0, target.brty)
+        except nfc.clf.TimeoutError:
+            return None
+
+        log.debug("rcvd SENS_RES %s", hexlify(sens_res).decode())
+
+        if sens_res[0] & 0x1F == 0:
+            log.debug("type 1 tag target found")
+            target = nfc.clf.RemoteTarget(target.brty, _addr=addr)
+            target.sens_res = sens_res
+            if sens_res[1] & 0x0F == 0b1100:
+                rid_cmd = bytearray.fromhex("78 0000 00000000")
+                log.debug("send RID_CMD %s", hexlify(rid_cmd).decode())
+                try:
+                    self._send_data(brty, rid_cmd, self.addr)
+                    brty, rid_res, addr = self._recv_data(1.0, brty)
+                    target.rid_res = rid_res
+                except nfc.clf.CommunicationError as error:
+                    log.debug(error)
+                    return None
+            return target
+
+        # other than type 1 tag
+        try:
+            if target.sel_req:
+                uid = target.sel_req
+                if len(uid) > 4:
+                    uid = b"\x88" + uid
+                if len(uid) > 8:
+                    uid = uid[0:4] + b"\x88" + uid[4:]
+                for i, sel_cmd in zip(range(0, len(uid), 4), b"\x93\x95\x97"):
+                    sel_req = bytearray([sel_cmd, 0x70]) + uid[i:i+4]
+                    sel_req.append(reduce(operator.xor, sel_req[2:6]))  # BCC
+                    log.debug("send SEL_REQ {}".format(
+                            hexlify(sel_req).decode()))
+                    self._send_data(brty, sel_req, addr)
+                    brty, sel_res, addr = self._recv_data(0.5, brty)
+                    log.debug("rcvd SEL_RES {}".format(
+                            hexlify(sel_res).decode()))
+                uid = target.sel_req
+            else:
+                uid = bytearray()
+                for sel_cmd in b"\x93\x95\x97":
+                    sdd_req = bytearray([sel_cmd, 0x20])
+                    log.debug("send SDD_REQ {}".format(
+                            hexlify(sdd_req).decode()))
+                    self._send_data(brty, sdd_req, addr)
+                    brty, sdd_res, addr = self._recv_data(0.5, brty)
+                    log.debug("rcvd SDD_RES {}".format(
+                            hexlify(sdd_res).decode()))
+                    sel_req = bytearray([sel_cmd, 0x70]) + sdd_res
+                    log.debug("send SEL_REQ {}".format(
+                            hexlify(sel_req).decode()))
+                    self._send_data(brty, sel_req, addr)
+                    brty, sel_res, addr = self._recv_data(0.5, brty)
+                    log.debug("rcvd SEL_RES {}".format(
+                            hexlify(sel_res).decode()))
+                    if sel_res[0] & 0b00000100:
+                        uid = uid + sdd_res[1:4]
+                    else:
+                        uid = uid + sdd_res[0:4]
+                        break
+            if sel_res[0] & 0b00000100 == 0:
+                target = nfc.clf.RemoteTarget(target.brty, _addr=addr)
+                target.sens_res = sens_res
+                target.sel_res = sel_res
+                target.sdd_res = uid
+                return target
+        except nfc.clf.CommunicationError as error:
+            log.debug(error)
+
+    def sense_ttb(self, target):
+        self._create_socket()
+
+        if target.brty not in ("106B", "212B", "424B"):
+            message = "unsupported bitrate {0}".format(target.brty)
+            raise nfc.clf.UnsupportedTargetError(message)
+
+        sensb_req = (target.sensb_req if target.sensb_req else
+                     bytearray.fromhex("050010"))
+
+        log.debug("send SENSB_REQ %s", hexlify(sensb_req).decode())
+        try:
+            self._send_data(target.brty, sensb_req, self.addr)
+            brty, sensb_res, addr = self._recv_data(1.0, target.brty)
+        except nfc.clf.CommunicationError:
+            return None
+
+        if len(sensb_res) >= 12 and sensb_res[0] == 0x50:
+            log.debug("rcvd SENSB_RES %s", hexlify(sensb_res).decode())
+            return nfc.clf.RemoteTarget(brty, sensb_res=sensb_res, _addr=addr)
+
+    def sense_ttf(self, target):
+        self._create_socket()
+
+        log.debug("sense_ttf for %s on %s:%d", target, *self.addr)
+
+        if target.brty not in ("212F", "424F"):
+            message = "unsupported bitrate {0}".format(target.brty)
+            raise nfc.clf.UnsupportedTargetError(message)
+
+        if not target.sensf_req:
+            sensf_req = bytearray.fromhex("0600FFFF0100")
+        else:
+            sensf_req = bytearray([len(target.sensf_req)+1]) + target.sensf_req
+
+        log.debug("send SENSF_REQ {}".format(
+                hexlify(memoryview(sensf_req)[1:]).decode()))
+        try:
+            self._send_data(target.brty, sensf_req, self.addr)
+            brty, data, addr = self._recv_data(1.0, target.brty)
+        except nfc.clf.CommunicationError:
+            return None
+
+        if len(data) >= 18 and data[0] == len(data) and data[1] == 1:
+            log.debug("rcvd SENSF_RES %s", hexlify(data[1:]).decode())
+            return nfc.clf.RemoteTarget(brty, sensf_res=data[1:], _addr=addr)
+
+    def sense_dep(self, target):
+        info = "{device} does not support sense for active DEP Target"
+        raise nfc.clf.UnsupportedTargetError(info.format(device=self))
+
+    def listen_tta(self, target, timeout):
+        self._create_socket()
+
+        log.debug("listen_tta for %.3f seconds on %s:%d", timeout, *self.addr)
+
+        time_to_return = time.time() + timeout
+        if not self._bind_socket(time_to_return):
+            log.debug("failed to bind socket")
+            return None
+
+        log.debug("wait for data on socket %s:%d", *self.socket.getsockname())
+        return self._listen_tta(target, time_to_return)
+
+    def _listen_tta(self, target, time_to_return, init=None):
+        sdd_res = bytearray(target.sdd_res)
+        if len(sdd_res) > 4:
+            sdd_res.insert(0, 0x88)
+        if len(sdd_res) > 8:
+            sdd_res.insert(4, 0x88)
+        sdd_res.insert(4, reduce(operator.xor, sdd_res[0:4]))
+        if len(sdd_res) > 5:
+            sdd_res.insert(9, reduce(operator.xor, sdd_res[5:9]))
+        if len(sdd_res) > 10:
+            sdd_res.insert(14, reduce(operator.xor, sdd_res[10:14]))
+        sel_res = bytearray([target.sel_res[0] & 0b11111011])
+
+        while time.time() < time_to_return:
+            if init is None:
+                wait = max(0.5, time_to_return - time.time())
+                try:
+                    brty, data, addr = self._recv_data(wait, target.brty)
+                except nfc.clf.TimeoutError:
+                    return None
+                except nfc.clf.CommunicationError:
+                    continue
+            else:
+                (brty, data, addr), init = init, None
+            if data == b"\x26":
+                log.debug("rcvd SENS_REQ %s", hexlify(data).decode())
+                sens_res = target.sens_res
+                log.debug("send SENS_RES %s", hexlify(sens_res).decode())
+                self._send_data(brty, sens_res, addr)
+            elif data == b"\x93\x20":
+                log.debug("rcvd SDD_REQ CL1 %s", hexlify(data).decode())
+                log.debug("send SDD_RES CL1 %s",
+                          hexlify(sdd_res[0:5]).decode())
+                self._send_data(brty, sdd_res[0:5], addr)
+            elif data == b"\x95\x20" and len(sdd_res) > 5:
+                log.debug("rcvd SDD_REQ CL2 %s", hexlify(data).decode())
+                log.debug("send SDD_RES CL2 %s",
+                          hexlify(sdd_res[5:10]).decode())
+                self._send_data(brty, sdd_res[5:10], addr)
+            elif data == b"\x97\x20" and len(sdd_res) > 10:
+                log.debug("rcvd SDD_REQ CL3 %s", hexlify(data).decode())
+                log.debug("send SDD_RES CL3 %s",
+                          hexlify(sdd_res[10:15]).decode())
+                self._send_data(brty, sdd_res[10:15], addr)
+            elif data == b"\x93\x70" + sdd_res[0:5]:
+                log.debug("rcvd SEL_REQ Cl1 %s", hexlify(data).decode())
+                sel_res[0] = (sel_res[0] & 0xFB) | (len(sdd_res) > 5) << 2
+                log.debug("send SEL_RES %s", hexlify(sel_res).decode())
+                self._send_data(brty, sel_res, addr)
+            elif data == b"\x95\x70" + sdd_res[5:10]:
+                log.debug("rcvd SEL_REQ CL2 %s", hexlify(data).decode())
+                sel_res[0] = (sel_res[0] & 0xFB) | (len(sdd_res) > 10) << 2
+                log.debug("send SEL_RES %s", hexlify(sel_res).decode())
+                self._send_data(brty, sel_res, addr)
+            elif data == b"\x95\x70" + sdd_res[10:15]:
+                log.debug("rcvd SEL_REQ CL3 %s", hexlify(data).decode())
+                sel_res[0] = (sel_res[0] & 0xFB) | (len(sdd_res) > 15) << 2
+                log.debug("send SEL_RES %s", hexlify(sel_res).decode())
+                self._send_data(brty, sel_res, addr)
+            elif sel_res[0] & 0b00000100 == 0:
+                target = nfc.clf.LocalTarget(
+                    brty, _addr=addr, sens_res=target.sens_res,
+                    sdd_res=target.sdd_res, sel_res=target.sel_res)
+                if ((data[0] == 0xF0 and len(data) >= 18 and
+                     data[1] == len(data)-1 and data[2:4] == b"\xD4\x00")):
+                    target.atr_req = data[2:]
+                elif data[0] == 0xE0:
+                    target.tt4_cmd = data[:]
+                else:
+                    target.tt2_cmd = data[:]
+                return target
+
+    def listen_ttb(self, target, timeout):
+        self._create_socket()
+
+        log.debug("listen_ttb for %.3f seconds on %s:%d", timeout, *self.addr)
+
+        time_to_return = time.time() + timeout
+        if not self._bind_socket(time_to_return):
+            log.debug("failed to bind socket")
+            return None
+
+        assert target.sensb_res and len(target.sensb_res) >= 12
+        log.debug("wait for data on socket %s:%d", *self.socket.getsockname())
+
+        while time.time() < time_to_return:
+            wait = max(0.5, time_to_return - time.time())
+            try:
+                brty, data, addr = self._recv_data(wait, target.brty)
+            except nfc.clf.TimeoutError:
+                return None
+            except nfc.clf.CommunicationError:
+                continue
+            if data and len(data) == 3 and data.startswith(b'\x05'):
+                req = "ALLB_REQ" if data[1] & 0x08 else "SENSB_REQ"
+                sensb_req = data
+                log.debug("rcvd %s %s", req, hexlify(sensb_req).decode())
+                log.debug("send SENSB_RES %s",
+                          hexlify(target.sensb_res).decode())
+                self._send_data(brty, target.sensb_res, addr)
+                brty, data, addr = self._recv_data(wait, target.brty)
+                return nfc.clf.LocalTarget(brty, sensb_req=sensb_req,
+                                           sensb_res=target.sensb_res,
+                                           tt4_cmd=data, _addr=addr)
+
+    def listen_ttf(self, target, timeout):
+        self._create_socket()
+
+        log.debug("listen_ttf for %.3f seconds on %s:%d", timeout, *self.addr)
+
+        time_to_return = time.time() + timeout
+        if not self._bind_socket(time_to_return):
+            log.debug("failed to bind socket")
+            return None
+
+        log.debug("wait for data on socket %s:%d", *self.socket.getsockname())
+        return self._listen_ttf(target, time_to_return)
+
+    def _listen_ttf(self, target, time_to_return, init=None):
+        sensf_req = sensf_res = None
+        while time.time() < time_to_return:
+            if init is None:
+                wait = max(0.5, time_to_return - time.time())
+                try:
+                    brty, data, addr = self._recv_data(wait, target.brty)
+                except nfc.clf.TimeoutError:
+                    return None
+                except nfc.clf.CommunicationError:
+                    continue
+            else:
+                (brty, data, addr), init = init, None
+            if data and len(data) == data[0]:
+                if data.startswith(b"\x06\x00"):
+                    (sensf_req, sensf_res) = (data[1:], target.sensf_res[:])
+                    if (((sensf_req[1] == 255 or
+                          sensf_req[1] == sensf_res[17]) and
+                         (sensf_req[2] == 255 or
+                          sensf_req[2] == sensf_res[18]))):
+                        data = sensf_res[0:17]
+                        if sensf_req[3] == 1:
+                            data += sensf_res[17:19]
+                        if sensf_req[3] == 2:
+                            data += bytearray(
+                                    [0x00, 1 << (target.brty == "424F")])
+                        data = bytearray([len(data)+1]) + data
+                        self._send_data(brty, data, addr)
+                    else:
+                        sensf_req = sensf_res = None
+                elif sensf_req and sensf_res:
+                    if data[2:10] == target.sensf_res[1:9]:
+                        target = nfc.clf.LocalTarget(brty, _addr=addr)
+                        target.sensf_req = sensf_req
+                        target.sensf_res = sensf_res
+                        target.tt3_cmd = data[1:]
+                        return target
+                    if data[1:11] == b'\xD4\x00' + target.sensf_res[1:9]:
+                        target = nfc.clf.LocalTarget(brty, _addr=addr)
+                        target.sensf_req = sensf_req
+                        target.sensf_res = sensf_res
+                        target.atr_req = data[1:]
+                        return target
+
+    def listen_dep(self, target, timeout):
+        self._create_socket()
+
+        log.debug("listen_dep for %.3f seconds on %s:%d", timeout, *self.addr)
+        assert target.sensf_res is not None
+        assert target.sens_res is not None
+        assert target.sdd_res is not None
+        assert target.sel_res is not None
+        assert target.atr_res is not None
+        assert len(target.sensf_res) == 19
+        assert len(target.sens_res) == 2
+        assert len(target.sdd_res) == 4
+        assert len(target.sel_res) == 1
+        assert len(target.atr_res) >= 17 and len(target.atr_res) <= 64
+
+        time_to_return = time.time() + timeout
+        if not self._bind_socket(time_to_return):
+            log.debug("failed to bind socket")
+            return None
+
+        log.debug("wait for data on socket %s:%d", *self.socket.getsockname())
+        atr_res = bytearray(target.atr_res)
+
+        while time.time() < time_to_return:
+            wait = max(0, time_to_return - time.time())
+            try:
+                result = self._recv_data(wait, '106A', '212F', '424F')
+                brty, data, addr = result
+            except nfc.clf.CommunicationError:
+                return None
+
+            target.brty = brty
+            if brty == '106A':
+                if data == b"\x26":
+                    init = (brty, data, addr)
+                    target = self._listen_tta(target, time_to_return, init)
+                elif (len(data) >= 18 and data[1] == len(data)-1 and
+                      data[0] == 0xF0 and data[2:4] == b'\xD4\x00'):
+                    target = nfc.clf.LocalTarget(
+                        brty, atr_res=target.atr_res, atr_req=data[2:])
+            elif brty in ('212F', '424F') and data[0] == len(data):
+                if data.startswith(b'\x06\x00'):
+                    init = (brty, data, addr)
+                    target = self._listen_ttf(target, time_to_return, init)
+                elif len(data) >= 17 and data[1:3] == b'\xD4\x00':
+                    target = nfc.clf.LocalTarget(
+                        brty, atr_res=target.atr_res, atr_req=data[1:])
+
+            if target and target.atr_req:
+                target.atr_res = atr_res
+                log.debug("rcvd ATR_REQ %s", hexlify(target.atr_req).decode())
+                log.debug("send ATR_RES %s", hexlify(target.atr_res).decode())
+                data = bytearray([len(atr_res) + 1]) + atr_res
+                if brty == '106A':
+                    data.insert(0, 0xF0)
+                self._send_data(brty, data, addr)
+                brty, data, addr = self._recv_data(wait, brty)
+                try:
+                    if brty == '106A':
+                        assert data.pop(0) == 0xF0
+                    assert len(data) == data.pop(0)
+                except AssertionError:
+                    return None
+                if data.startswith(b'\xD4\x04'):
+                    target.psl_req = data[:]
+                    target.psl_res = b'\xD5\x05' + target.psl_req[2:3]
+                    log.debug("rcvd PSL_REQ %s",
+                              hexlify(target.psl_req).decode())
+                    log.debug("send PSL_RES %s",
+                              hexlify(target.psl_res).decode())
+                    data = bytearray([len(target.psl_res) + 1]) \
+                        + target.psl_res
+                    if brty == '106A':
+                        data.insert(0, 0xF0)
+                    self._send_data(brty, data, addr)
+                    brty = ('106A', '212F', '424F')[target.psl_req[3] >> 3 & 7]
+                    target.brty, data, addr = self._recv_data(wait, brty)
+                    try:
+                        if brty == '106A':
+                            assert data.pop(0) == 0xF0
+                        assert len(data) == data.pop(0)
+                    except AssertionError:
+                        return None
+                if data.startswith(b'\xD4\x08'):
+                    log.debug("rcvd DSL_REQ %s", hexlify(data).decode())
+                    data = b'\xD5\x09' + data[2:3]
+                    log.debug("send DSL_RES %s", hexlify(data).decode())
+                    data = bytearray([len(data) + 1]) + data
+                    if brty == '106A':
+                        data.insert(0, 0xF0)
+                    self._send_data(brty, data, addr)
+                    return None
+                if data.startswith(b'\xD4\x0A'):
+                    log.debug("rcvd RLS_REQ %s", hexlify(data).decode())
+                    data = b'\xD5\x0B' + data[2:3]
+                    log.debug("send RLS_RES %s", hexlify(data).decode())
+                    data = bytearray([len(data) + 1]) + data
+                    if brty == '106A':
+                        data.insert(0, 0xF0)
+                    self._send_data(brty, data, addr)
+                    return None
+                if data.startswith(b'\xD4\x06'):
+                    target.dep_req = data[:]
+                    return target
+                return None
+
+    def send_cmd_recv_rsp(self, target, data, timeout):
+        # send data, data should normally not be None for the Initiator
+        if data is not None:
+            self._send_data(target.brty, data, target._addr)
+
+        # receive response data unless the timeout is zero
+        if timeout > 0:
+            brty, data, addr = self._recv_data(timeout, target.brty)
+            return data
+
+    def send_rsp_recv_cmd(self, target, data, timeout):
+        # send data, data may be none as target keeps silence on error
+        if data is not None:
+            self._send_data(target.brty, data, target._addr)
+
+        # recv response data unless the timeout is zero
+        if timeout is None or timeout > 0:
+            brty, data, addr = self._recv_data(timeout, target.brty)
+            return data
+
+    def get_max_send_data_size(self, target):
+        return 290
+
+    def get_max_recv_data_size(self, target):
+        return 290
+
+    def _create_socket(self):
+        if self.socket is None:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self.sent_data = self.rcvd_data = 0
+
+    def _bind_socket(self, time_to_return):
+        addr = ('0.0.0.0', self.addr[1])
+        while time.time() < time_to_return:
+            log.debug("trying to bind socket to %s:%d", *addr)
+            try:
+                self.socket.bind(addr)
+                return True
+            except socket.error as error:
+                log.debug("bind failed with %s", error)
+                if error.errno == errno.EADDRINUSE:
+                    return False
+                else:
+                    raise error
+
+    def _send_data(self, brty, data, addr):
+        data = (b"%s %s" % (brty.encode('latin'), hexlify(data))).strip()
+        log.log(logging.DEBUG-1, ">>> %s to %s:%s", data.decode(), *addr)
+        ret = self.socket.sendto(data, addr)
+        if ret != len(data):
+            raise nfc.clf.TransmissionError("failed to send data")
+        self.sent_data += len(data)
+
+    def _recv_data(self, timeout, *brty_list):
+        time_to_return = None if timeout is None else (time.time() + timeout)
+        while timeout is None or time.time() < time_to_return:
+            wait = None if timeout is None else (time_to_return - time.time())
+            if len(select.select([self.socket], [], [], wait)[0]) == 1:
+                data, addr = self.socket.recvfrom(1024)
+                log.log(logging.DEBUG-1, "<<< %s from %s:%d", data, *addr)
+                if data.startswith(b"RFOFF"):
+                    raise nfc.clf.BrokenLinkError("RFOFF")
+                try:
+                    brty, data = data.split()
+                except ValueError:
+                    raise nfc.clf.TransmissionError("no data")
+                brty = brty.decode("ascii")
+                data = bytearray(unhexlify(data))
+                self.rcvd_data += len(data)
+                if brty in brty_list:
+                    return brty, data, addr
+        raise nfc.clf.TimeoutError("no data received")
+
+
+def init(host, port):
+    import platform
+    device = Device(host, port)
+    device._vendor_name = platform.uname()[0]
+    device._device_name = "IP-Stack"
+    device._chipset_name = "UDP"
+    return device

src/lib/nfc/dep.py

@@ -0,0 +1,895 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 src.lib.nfc.clf
+
+import os
+import time
+import collections
+import struct
+from binascii import hexlify
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class DataExchangeProtocol(object):
+    class Counter(object):
+        def __init__(self):
+            self.sent = collections.defaultdict(int)
+            self.rcvd = collections.defaultdict(int)
+
+        @property
+        def sent_count(self):
+            return sum(self.sent.values())
+
+        @property
+        def rcvd_count(self):
+            return sum(self.rcvd.values())
+
+        def __str__(self):
+            s = "sent/rcvd {0}/{1}".format(self.sent_count, self.rcvd_count)
+            for name in sorted(set(list(self.sent.keys())
+                                   + list(self.rcvd.keys()))):
+                s += " {name} {sent}/{rcvd}".format(
+                    name=name, sent=self.sent[name], rcvd=self.rcvd[name])
+            return s
+
+    def __init__(self, clf):
+        self.pcnt = DataExchangeProtocol.Counter()
+        self.clf = clf
+        self.gbi = b""
+        self.gbt = b""
+
+    @property
+    def general_bytes(self):
+        """The general bytes received with the ATR exchange"""
+        pass
+
+    @property
+    def role(self):
+        """Role in DEP communication, either 'Target' or 'Initiator'"""
+        pass
+
+
+class Initiator(DataExchangeProtocol):
+    ROLE = "Initiator"
+
+    def __init__(self, clf):
+        DataExchangeProtocol.__init__(self, clf)
+        self.target = None
+        self.miu = None  # maximum information unit size
+        self.did = None  # dep device identifier
+        self.nad = None  # dep node address
+        self.gbt = None  # general bytes from target
+        self.pni = None  # dep packet number information
+        self.rwt = None  # target response waiting time
+        self._acm = None  # active communication mode flag
+
+    @property
+    def role(self):
+        return "Initiator"
+
+    @property
+    def general_bytes(self):
+        return self.gbt
+
+    @property
+    def acm(self):
+        return bool(self._acm)
+
+    def __str__(self):
+        msg = "NFC-DEP Initiator {brty} {mode} mode MIU={miu} RWT={rwt:.6f}"
+        return msg.format(brty=self.target.brty, miu=self.miu, rwt=self.rwt,
+                          mode=("passive", "active")[self.acm])
+
+    def activate(self, target=None, **options):
+        """Activate DEP communication with a target."""
+        log.debug("initiator options: {0}".format(options))
+
+        self.did = options.get('did', None)
+        self.nad = options.get('nad', None)
+        self.gbi = options.get('gbi', b'')[0:48]
+        self.brs = min(max(0, options.get('brs', 2)), 2)
+        self.lri = min(max(0, options.get('lri', 3)), 3)
+        if self._acm is None or 'acm' in options:
+            self._acm = bool(options.get('acm', True))
+
+        assert self.did is None or 0 <= self.did <= 255
+        assert self.nad is None or 0 <= self.nad <= 255
+
+        ppi = (self.lri << 4) | (bool(self.gbi) << 1) | int(bool(self.nad))
+        did = 0 if self.did is None else self.did
+        atr_req = ATR_REQ(os.urandom(10), did, 0, 0, ppi, self.gbi)
+        psl_req = PSL_REQ(did, (0, 9, 18)[self.brs], self.lri)
+        atr_res = psl_res = None
+        self.target = target
+
+        if self.target is None and self.acm is True:
+            log.debug("searching active communication mode target at 106A")
+            tg = nfc.clf.RemoteTarget("106A", atr_req=atr_req.encode())
+            try:
+                self.target = self.clf.sense(tg, iterations=2, interval=0.1)
+            except nfc.clf.UnsupportedTargetError:
+                self._acm = False
+            except nfc.clf.CommunicationError:
+                pass
+            else:
+                if self.target:
+                    atr_res = ATR_RES.decode(self.target.atr_res)
+                else:
+                    self._acm = None
+
+        if self.target is None:
+            log.debug("searching passive communication mode target at 106A")
+            target = nfc.clf.RemoteTarget("106A")
+            target = self.clf.sense(target, iterations=2, interval=0.1)
+            if target and target.sel_res and bool(target.sel_res[0] & 0x40):
+                self.target = target
+
+        if self.target is None and self.brs > 0:
+            log.debug("searching passive communication mode target at 212F")
+            target = nfc.clf.RemoteTarget("212F", sensf_req=b'\0\xFF\xFF\0\0')
+            target = self.clf.sense(target, iterations=2, interval=0.1)
+            if target and target.sensf_res.startswith(b'\1\1\xFE'):
+                atr_req.nfcid3 = target.sensf_res[1:9] + b'ST'
+                self.target = target
+
+        if self.target and self.target.atr_res is None:
+            try:
+                atr_res = self.send_req_recv_res(atr_req, 1.0)
+            except nfc.clf.CommunicationError:
+                pass
+            if atr_res is None:
+                log.debug("NFC-DEP Attribute Request failed")
+                return None
+
+        if self.target and atr_res:
+            if self.brs > ('106A', '212F', '424F').index(self.target.brty):
+                try:
+                    psl_res = self.send_req_recv_res(psl_req, 0.1)
+                except nfc.clf.CommunicationError:
+                    pass
+                if psl_res is None:
+                    log.debug("NFC-DEP Parameter Selection failed")
+                    return None
+                self.target.brty = ('212F', '424F')[self.brs-1]
+
+            self.rwt = (4096/13.56E6
+                        * 2**(atr_res.wt if atr_res.wt < 15 else 14))
+            self.miu = (atr_res.lr-3 - int(self.did is not None)
+                        - int(self.nad is not None))
+            self.gbt = atr_res.gb
+            self.pni = 0
+
+            log.info("running as " + str(self))
+            return self.gbt
+
+    def deactivate(self, release=True):
+        log.debug("deactivate {0}".format(self))
+        req = RLS_REQ(self.did) if release else DSL_REQ(self.did)
+        try:
+            res = self.send_req_recv_res(req, 0.1)
+        except nfc.clf.CommunicationError:
+            return
+        else:
+            if res.did != req.did:
+                log.error("target returned wrong DID in " + res.PDU_NAME)
+        finally:
+            log.debug("packets {0}".format(self.pcnt))
+
+    def exchange(self, send_data, timeout):
+        def INF(pni, data, more, did, nad):
+            pdu_type = (DEP_REQ.LastInformation, DEP_REQ.MoreInformation)[more]
+            pfb = DEP_REQ.PFB(pdu_type, nad is not None, did is not None, pni)
+            return DEP_REQ(pfb, did, nad, data)
+
+        def ACK(pni, did, nad):
+            pdu_type = DEP_REQ.PositiveAck
+            pfb = DEP_REQ.PFB(pdu_type, nad is not None, did is not None, pni)
+            return DEP_REQ(pfb, did, nad, data=None)
+
+        def RTOX(rtox, did, nad):
+            if not 0 < rtox < 60:
+                error = "NFC-DEP RTOX must be in range 1 to 59"
+                raise nfc.clf.ProtocolError(error)
+            pdu_type = DEP_REQ.TimeoutExtension
+            pfb = DEP_REQ.PFB(pdu_type, nad is not None, did is not None, 0)
+            return DEP_REQ(pfb, did, nad, data=bytearray([rtox]))
+
+        # log.debug("dep raw >> %s", hexlify(send_data).decode())
+        send_data = bytearray(send_data)
+
+        while send_data:
+            data = send_data[0:self.miu]
+            del send_data[0:self.miu]
+            req = INF(self.pni, data, bool(send_data), self.did, self.nad)
+            res = self.send_dep_req_recv_dep_res(req, self.rwt, timeout)
+            if res.pfb.fmt == DEP_RES.TimeoutExtension:
+                for i in range(3):
+                    req = RTOX(res.data[0], self.did, self.nad)
+                    rwt = res.data[0] * self.rwt
+                    log.warning("target requested %.3f sec more time", rwt)
+                    res = self.send_dep_req_recv_dep_res(req, rwt, timeout)
+                    if res.pfb.fmt != DEP_RES.TimeoutExtension:
+                        break
+                else:
+                    log.error("too many timeout extension requests")
+                    raise nfc.clf.TimeoutError("timeout extension")
+            if res.pfb.fmt == DEP_RES.PositiveAck:
+                if not send_data:
+                    error = "unexpected or out-of-sequence NFC-DEP ACK PDU"
+                    raise nfc.clf.ProtocolError(error)
+            if res.pfb.pni != self.pni:
+                raise nfc.clf.ProtocolError("wrong NFC-DEP packet number")
+            self.pni = (self.pni + 1) & 0x3
+
+        if ((res.pfb.fmt != DEP_RES.LastInformation and
+             res.pfb.fmt != DEP_RES.MoreInformation)):
+            error = "expected NFC-DEP INF PDU after sending"
+            raise nfc.clf.ProtocolError(error)
+
+        recv_data = res.data
+
+        while res.pfb.fmt == DEP_RES.MoreInformation:
+            req = ACK(self.pni, self.did, self.nad)
+            res = self.send_dep_req_recv_dep_res(req, self.rwt, timeout)
+            if res.pfb.fmt == DEP_RES.TimeoutExtension:
+                for i in range(3):
+                    req = RTOX(res.data[0], self.did, self.nad)
+                    rwt = res.data[0] * self.rwt
+                    log.warning("target requested %.3f sec more time", rwt)
+                    res = self.send_dep_req_recv_dep_res(req, rwt, timeout)
+                    if res.pfb.fmt != DEP_RES.TimeoutExtension:
+                        break
+                else:
+                    log.error("too many timeout extension requests")
+                    raise nfc.clf.TimeoutError("timeout extension")
+            if ((res.pfb.fmt != DEP_RES.LastInformation and
+                 res.pfb.fmt != DEP_RES.MoreInformation)):
+                error = "NFC-DEP chaining not continued after ACK"
+                raise nfc.clf.ProtocolError(error)
+            if res.pfb.pni != self.pni:
+                raise nfc.clf.ProtocolError("wrong NFC-DEP packet number")
+            recv_data += res.data
+            self.pni = (self.pni + 1) & 0x3
+
+        # log.debug("dep raw << %s", hexlify(recv_data).decode())
+        return recv_data
+
+    def send_dep_req_recv_dep_res(self, req, rwt, timeout):
+        def NAK(pni, did, nad):
+            pdu_type = DEP_REQ.NegativeAck
+            pfb = DEP_REQ.PFB(
+                pdu_type, nad is not None, did is not None, self.pni)
+            return DEP_REQ(pfb, did, nad, data=None)
+
+        def ATN():
+            pdu_type = DEP_REQ.Attention
+            pfb = DEP_REQ.PFB(pdu_type, nad=False, did=False, pni=0)
+            return DEP_REQ(pfb, did=None, nad=None, data=None)
+
+        def request_attention(self, n_retry_atn, rwt, deadline):
+            req = ATN()
+            for i in range(n_retry_atn):
+                timeout = min(rwt, deadline - time.time())
+                if timeout <= 0:
+                    raise nfc.clf.TimeoutError
+                try:
+                    res = self.send_req_recv_res(req, timeout)
+                except nfc.clf.CommunicationError:
+                    continue
+                if res.pfb.fmt == DEP_RES.TimeoutExtension:
+                    error = "received NFC-DEP RTOX response to NACK or ATN"
+                    raise nfc.clf.ProtocolError(error)
+                if res.pfb.fmt != DEP_RES.Attention:
+                    error = "expected NFC-DEP Attention response"
+                    raise nfc.clf.ProtocolError(error)
+                return
+            error = "unrecoverable NFC-DEP error in attention request"
+            raise nfc.clf.ProtocolError(error)
+
+        def request_retransmission(self, n_retry_nak, rwt, deadline):
+            req = NAK(self.pni, self.did, self.nad)
+            for i in range(n_retry_nak):
+                timeout = min(rwt, deadline - time.time())
+                if timeout <= 0:
+                    raise nfc.clf.TimeoutError
+                try:
+                    res = self.send_req_recv_res(req, timeout)
+                except nfc.clf.CommunicationError:
+                    continue
+                if res.pfb.fmt == DEP_RES.TimeoutExtension:
+                    error = "received NFC-DEP RTOX response to NACK or ATN"
+                    raise nfc.clf.ProtocolError(error)
+                expected = (DEP_RES.LastInformation, DEP_RES.MoreInformation)
+                if res.pfb.fmt not in expected:
+                    error = "unrecoverable NFC-DEP transmission error"
+                    raise nfc.clf.ProtocolError(error)
+                return res
+            error = "unrecoverable NFC-DEP error in retransmission request"
+            raise nfc.clf.ProtocolError(error)
+
+        if rwt > timeout:
+            text = "response waiting time %.3f exceeds the timeout of %.3f sec"
+            log.warning(text, rwt, timeout)
+
+        deadline = time.time() + timeout
+        while True:
+            timeout = min(rwt, deadline - time.time())
+            if timeout <= 0:
+                raise nfc.clf.TimeoutError()
+            try:
+                res = self.send_req_recv_res(req, timeout)
+                break
+            except nfc.clf.TimeoutError:
+                request_attention(self, 2, rwt, deadline)
+                continue
+            except nfc.clf.TransmissionError:
+                res = request_retransmission(self, 2, rwt, deadline)
+                break
+
+        if res.pfb.fmt == DEP_RES.NegativeAck:
+            error = "received NFC-DEP NACK PDU from Target"
+            raise nfc.clf.ProtocolError(error)
+
+        return res
+
+    def send_req_recv_res(self, req, timeout):
+        log.debug(">> {0}".format(req))
+        pcnt_key = req.PDU_NAME[:3]
+        if isinstance(req, DEP_REQ):
+            pcnt_key += " " + req.pfb.FMT_NAME
+        self.pcnt.sent[pcnt_key] += 1
+
+        cmd = self.encode_frame(req)
+        rsp = self.clf.exchange(cmd, timeout)
+        res = self.decode_frame(rsp)
+        if res.PDU_NAME[0:3] != req.PDU_NAME[0:3]:
+            raise nfc.clf.ProtocolError("invalid response for " + req.PDU_NAME)
+
+        log.debug("<< {0}".format(res))
+        pcnt_key = res.PDU_NAME[:3]
+        if isinstance(res, DEP_RES):
+            pcnt_key += " " + res.pfb.FMT_NAME
+        self.pcnt.rcvd[pcnt_key] += 1
+        return res
+
+    def encode_frame(self, packet):
+        frame = packet.encode()
+        frame = struct.pack("B", len(frame) + 1) + frame
+        if self.target.brty == '106A':
+            frame = b'\xF0' + frame
+        return bytearray(frame)
+
+    def decode_frame(self, frame):
+        if self.target.brty == '106A' and frame.pop(0) != 0xF0:
+            error = "first NFC-DEP frame byte must be F0h for 106A"
+            raise nfc.clf.ProtocolError(error)
+        if len(frame) != frame.pop(0):
+            error = "NFC-DEP frame length byte must be data length + 1"
+            raise nfc.clf.ProtocolError(error)
+        if len(frame) < 2:
+            error = "NFC-DEP frame length byte must be from 3 to 255"
+            raise nfc.clf.TransmissionError(error)
+        if frame[0] != 0xD5 or frame[1] not in (1, 5, 7, 9, 11):
+            raise nfc.clf.ProtocolError("invalid NFC-DEP response code")
+        res_name = {1: 'ATR', 5: 'PSL', 7: 'DEP', 9: 'DSL', 11: 'RLS'}
+        return eval(res_name[frame[1]] + "_RES").decode(frame)
+
+
+class Target(DataExchangeProtocol):
+    def __init__(self, clf):
+        DataExchangeProtocol.__init__(self, clf)
+        self.miu = None  # maximum information unit size
+        self.did = None  # dep device identifier
+        self.nad = None  # dep node address
+        self.gbi = None  # general bytes from initiator
+        self.pni = None  # dep packet number information
+        self.rwt = None  # target response waiting time
+
+    @property
+    def role(self):
+        return "Target"
+
+    @property
+    def general_bytes(self):
+        return self.gbi
+
+    def __str__(self):
+        msg = "NFC-DEP Target {brty} {mode} mode MIU={miu} RWT={rwt:.6f}"
+        return msg.format(brty=self.target.brty, miu=self.miu, rwt=self.rwt,
+                          mode=("passive", "active")[self.acm])
+
+    def activate(self, timeout=None, **options):
+        """Activate DEP communication as a target."""
+
+        if timeout is None:
+            timeout = 1.0
+        gbt = options.get('gbt', b'')[0:47]
+        lrt = min(max(0, options.get('lrt', 3)), 3)
+        rwt = min(max(0, options.get('rwt', 8)), 14)
+
+        pp = (lrt << 4) | (bool(gbt) << 1) | int(bool(self.nad))
+        nfcid3t = bytearray.fromhex("01FE") + os.urandom(6) + b"ST"
+        atr_res = ATR_RES(nfcid3t, 0, 0, 0, rwt, pp, gbt)
+        atr_res = atr_res.encode()
+
+        target = nfc.clf.LocalTarget(atr_res=atr_res)
+        target.sens_res = bytearray.fromhex("0101")
+        target.sdd_res = bytearray.fromhex("08") + os.urandom(3)
+        target.sel_res = bytearray.fromhex("40")
+        target.sensf_res = bytearray.fromhex("01") + nfcid3t[0:8]
+        target.sensf_res += bytearray.fromhex("00000000 00000000 FFFF")
+
+        target = self.clf.listen(target, timeout)
+
+        if target and target.atr_req and target.dep_req:
+            log.debug("activated as " + str(target))
+
+            atr_req = ATR_REQ.decode(target.atr_req)
+            self.lrt = lrt
+            self.gbt = gbt
+            self.gbi = atr_req.gb
+            self.miu = atr_req.lr - 3
+            self.rwt = 4096/13.56E6 * pow(2, rwt)
+            self.did = atr_req.did if atr_req.did > 0 else None
+            self.acm = not (target.sens_res or target.sensf_res)
+            self.cmd = bytearray(
+                struct.pack("B", len(target.dep_req)+1) + target.dep_req)
+            if target.brty == "106A":
+                self.cmd = bytearray(b"\xF0" + self.cmd)
+            self.target = target
+
+            self.pcnt.rcvd["ATR"] += 1
+            self.pcnt.sent["ATR"] += 1
+            log.info("running as " + str(self))
+
+            return self.gbi
+
+    def deactivate(self, data=bytearray()):
+        try:
+            log.debug("deactivate {0}".format(self))
+            self._deactivate(data)
+        finally:
+            log.debug("packets {0}".format(self.pcnt))
+
+    def _deactivate(self, data):
+        def INF(pni, data, did, nad):
+            pdu_type = DEP_RES.LastInformation
+            pfb = DEP_RES.PFB(pdu_type, nad is not None, did is not None, pni)
+            return DEP_RES(pfb, did, nad, data)
+
+        def ATN(did, nad):
+            pdu_type = DEP_RES.Attention
+            pfb = DEP_RES.PFB(pdu_type, nad is not None, did is not None, 0)
+            return DEP_RES(pfb, did, nad, data=None)
+
+        res = None
+        deadline = time.time() + 1.0
+        while time.time() < deadline:  # pragma: no branch
+            try:
+                req = self.send_res_recv_req(res, deadline)
+            except nfc.clf.CommunicationError:
+                return
+            if req is None:
+                return
+            if req.did == self.did:
+                if type(req) in (DSL_REQ, RLS_REQ):
+                    RES = DSL_RES if type(req) == DSL_REQ else RLS_RES
+                    try:
+                        self.send_res_recv_req(RES(self.did), 0)
+                    except nfc.clf.CommunicationError:
+                        pass
+                    return
+                if type(req) == DEP_REQ:
+                    if req.pfb.fmt == DEP_REQ.Attention:
+                        res = ATN(self.did, self.nad)
+                    else:
+                        res = INF(req.pfb.pni, data, self.did, self.nad)
+                    continue
+            res = None
+
+    def exchange(self, send_data, timeout):
+        def INF(pni, data, more, did, nad):
+            pdu_type = (DEP_RES.LastInformation, DEP_RES.MoreInformation)[more]
+            pfb = DEP_RES.PFB(pdu_type, nad is not None, did is not None, pni)
+            return DEP_RES(pfb, did, nad, data)
+
+        def ACK(pni, did, nad):
+            pdu_type = DEP_RES.PositiveAck
+            pfb = DEP_RES.PFB(pdu_type, nad is not None, did is not None, pni)
+            return DEP_RES(pfb, did, nad, data=None)
+
+        if send_data is not None and len(send_data) == 0:
+            raise ValueError("send_data must not be empty")
+
+        deadline = time.time() + timeout
+
+        if self.cmd is not None:
+            # first command frame received in activate is injected in
+            # send_res_recv_req and self.cmd then set to None
+            assert send_data is None, "send_data should be None on first call"
+            req = self.send_dep_res_recv_dep_req(None, deadline)
+            self.pni = 0
+        else:
+            send_data = bytearray(send_data)
+            while send_data:
+                data = send_data[0:self.miu]
+                more = len(send_data) > self.miu
+                res = INF(self.pni, data, more, self.did, self.nad)
+                req = self.send_dep_res_recv_dep_req(res, deadline)
+                if req is None:
+                    return None
+                if more:
+                    if req.pfb.fmt is not DEP_REQ.PositiveAck:
+                        error = "expected ACK in NFC-DEP chaining"
+                        raise nfc.clf.ProtocolError(error)
+                self.pni = (self.pni + 1) & 0x3
+                if req.pfb.pni != self.pni:
+                    raise nfc.clf.ProtocolError("wrong NFC-DEP packet number")
+                del send_data[0:self.miu]
+
+        recv_data = bytearray()
+        while req.pfb.fmt == DEP_REQ.MoreInformation:
+            recv_data += req.data
+            res = ACK(self.pni, self.did, self.nad)
+            req = self.send_dep_res_recv_dep_req(res, deadline)
+            if req is None:
+                return None
+            self.pni = (self.pni + 1) & 0x3
+            if req.pfb.pni != self.pni:
+                raise nfc.clf.ProtocolError("wrong NFC-DEP packet number")
+
+        recv_data += req.data
+        return recv_data
+
+    def send_timeout_extension(self, rtox):
+        def RTOX(rtox, did, nad):
+            pdu_type = DEP_RES.TimeoutExtension
+            pfb = DEP_RES.PFB(pdu_type, nad is not None, did is not None, 0)
+            return DEP_RES(pfb, did, nad, data=bytearray([rtox]))
+
+        res = RTOX(rtox, self.did, self.nad)
+        req = self.send_dep_res_recv_dep_req(res, deadline=time.time()+1)
+        if type(req) == DEP_REQ and req.pfb.fmt == DEP_REQ.TimeoutExtension:
+            return req.data[0] & 0x3F
+
+    def send_dep_res_recv_dep_req(self, dep_res, deadline):
+        def ATN(did, nad):
+            pdu_type = DEP_RES.Attention
+            pfb = DEP_RES.PFB(pdu_type, nad is not None, did is not None, 0)
+            return DEP_RES(pfb, did, nad, data=None)
+
+        res = dep_res
+        dep_req = None
+        while dep_req is None:
+            req = self.send_res_recv_req(res, deadline)
+            if req is None:
+                return None
+            elif req.did != self.did:
+                log.debug("ignore non-matching device identifier")
+                res = None
+            elif type(req) == DSL_REQ:
+                return self.send_res_recv_req(DSL_RES(self.did), 0)
+            elif type(req) == RLS_REQ:
+                return self.send_res_recv_req(RLS_RES(self.did), 0)
+            elif type(req) == DEP_REQ:
+                if req.pfb.fmt == DEP_REQ.Attention:
+                    res = ATN(self.did, self.nad)
+                elif req.pfb.fmt == DEP_REQ.NegativeAck:
+                    res = dep_res
+                elif req.pfb.fmt == DEP_REQ.TimeoutExtension:
+                    dep_req = req
+                elif req.pfb.pni == self.pni:
+                    res = dep_res
+                else:
+                    dep_req = req
+            else:
+                log.debug("invalid command in data exchange context")
+                res = None
+        return dep_req
+
+    def send_res_recv_req(self, res, deadline):
+        frame = None
+
+        if self.cmd is not None:
+            # first command is received in activate
+            frame, self.cmd = self.cmd, None
+        else:
+            if res is not None:
+                log.debug(">> {0}".format(res))
+                pcnt_key = res.PDU_NAME[:3]
+                if isinstance(res, DEP_RES):
+                    pcnt_key += " " + res.pfb.FMT_NAME
+                self.pcnt.sent[pcnt_key] += 1
+                frame = self.encode_frame(res)
+            while True:
+                timeout = deadline-time.time() if deadline > time.time() else 0
+                try:
+                    frame = self.clf.exchange(frame, timeout=timeout)
+                except nfc.clf.TransmissionError:
+                    frame = None
+                else:
+                    break
+
+        if frame:
+            req = self.decode_frame(frame)
+            log.debug("<< {0}".format(req))
+            pcnt_key = req.PDU_NAME[:3]
+            if isinstance(req, DEP_REQ):
+                pcnt_key += " " + req.pfb.FMT_NAME
+            self.pcnt.rcvd[pcnt_key] += 1
+            return req
+
+    def encode_frame(self, packet):
+        frame = packet.encode()
+        frame = struct.pack("B", len(frame) + 1) + frame
+        if self.target.brty == '106A':
+            frame = b'\xF0' + frame
+        return bytearray(frame)
+
+    def decode_frame(self, frame):
+        if self.target.brty == '106A' and frame.pop(0) != 0xF0:
+            error = "first NFC-DEP frame byte must be F0h for 106A"
+            raise nfc.clf.ProtocolError(error)
+        if len(frame) != frame.pop(0):
+            error = "NFC-DEP frame length byte must be data length + 1"
+            raise nfc.clf.ProtocolError(error)
+        if len(frame) < 2:
+            error = "NFC-DEP frame length byte must be from 3 to 255"
+            raise nfc.clf.TransmissionError(error)
+        if frame[0] != 0xD4 or frame[1] not in (0, 4, 6, 8, 10):
+            raise nfc.clf.ProtocolError("invalid NFC-DEP command code")
+        req_name = {0: 'ATR', 4: 'PSL', 6: 'DEP', 8: 'DSL', 10: 'RLS'}
+        return eval(req_name[frame[1]] + "_REQ").decode(frame)
+
+
+#
+# Data Exchange Protocol Data Units
+#
+class ATR_REQ_RES(object):
+    def __str__(self):
+        nfcid3, gb = [hexlify(ba).decode() for ba in [self.nfcid3, self.gb]]
+        return self.PDU_SHOW.format(self=self, nfcid3=nfcid3, gb=gb)
+
+    @property
+    def lr(self):
+        return (64, 128, 192, 254)[(self.pp >> 4) & 0x3]
+
+
+class ATR_REQ(ATR_REQ_RES):
+    PDU_CODE = bytearray(b'\xD4\x00')
+    PDU_NAME = 'ATR-REQ'
+    PDU_SHOW = "{self.PDU_NAME} NFCID3={nfcid3} DID={self.did:02x} "\
+        "BS={self.bs:02x} BR={self.br:02x} PP={self.pp:02x} GB={gb}"
+
+    def __init__(self, nfcid3, did, bs, br, pp, gb):
+        self.nfcid3, self.did, self.bs, self.br, self.pp, self.gb = \
+            nfcid3, did, bs, br, pp, gb
+
+    def __len__(self):
+        return 16 + len(self.gb)
+
+    @staticmethod
+    def decode(data):
+        if data.startswith(ATR_REQ.PDU_CODE):
+            nfcid3, (did, bs, br, pp) = data[2:12], data[12:16]
+            gb = data[16:] if pp & 0x02 else bytearray()
+            return ATR_REQ(nfcid3, did, bs, br, pp, gb)
+
+    def encode(self):
+        data = ATR_REQ.PDU_CODE + self.nfcid3
+        data.extend([self.did, self.bs, self.br, self.pp])
+        return data + self.gb
+
+
+class ATR_RES(ATR_REQ_RES):
+    PDU_CODE = bytearray(b'\xD5\x01')
+    PDU_NAME = 'ATR-RES'
+    PDU_SHOW = "{self.PDU_NAME} NFCID3={nfcid3} DID={self.did:02x} "\
+        "BS={self.bs:02x} BR={self.br:02x} TO={self.to:02x} "\
+        "PP={self.pp:02x} GB={gb}"
+
+    def __init__(self, nfcid3, did, bs, br, to, pp, gb):
+        self.nfcid3, self.did, self.bs, self.br, self.to, self.pp, self.gb = \
+            nfcid3, did, bs, br, to, pp, gb
+
+    def __len__(self):
+        return 17 + len(self.gb)
+
+    @staticmethod
+    def decode(data):
+        if data.startswith(ATR_RES.PDU_CODE):
+            nfcid3, (did, bs, br, to, pp) = data[2:12], data[12:17]
+            gb = data[17:] if pp & 0x02 else bytearray()
+            return ATR_RES(nfcid3, did, bs, br, to, pp, gb)
+
+    def encode(self):
+        data = ATR_RES.PDU_CODE + self.nfcid3
+        data.extend([self.did, self.bs, self.br, self.to, self.pp])
+        return data + self.gb
+
+    @property
+    def wt(self):
+        return self.to & 0x0F
+
+
+class PSL_REQ_RES(object):
+    def __str__(self):
+        return self.PDU_SHOW.format(name=self.PDU_NAME, self=self)
+
+    @classmethod
+    def decode(cls, data):
+        if data.startswith(cls.PDU_CODE):
+            try:
+                return cls(*data[2:])
+            except TypeError:
+                errstr = "invalid format of the " + cls.PDU_NAME
+                raise nfc.clf.ProtocolError(errstr)
+
+
+class PSL_REQ(PSL_REQ_RES):
+    PDU_CODE = bytearray(b'\xD4\x04')
+    PDU_NAME = 'PSL-REQ'
+    PDU_SHOW = "{name} DID={self.did:02x} BRS={self.brs:02x} " \
+               "FSL={self.fsl:02x}"
+
+    def __init__(self, did, brs, fsl):
+        self.did, self.brs, self.fsl = did if did else 0, brs, fsl
+
+    def encode(self):
+        return PSL_REQ.PDU_CODE + bytearray([self.did, self.brs, self.fsl])
+
+    @property
+    def dsi(self):
+        return self.brs >> 3 & 0x07
+
+    @property
+    def dri(self):
+        return self.brs & 0x07
+
+    @property
+    def lr(self):
+        return (64, 128, 192, 254)[self.fsl & 0x03]
+
+
+class PSL_RES(PSL_REQ_RES):
+    PDU_CODE = bytearray(b'\xD5\x05')
+    PDU_NAME = 'PSL-RES'
+    PDU_SHOW = "{name} DID={self.did:02x}"
+
+    def __init__(self, did):
+        self.did = did
+
+    def encode(self):
+        return PSL_RES.PDU_CODE + bytearray([self.did])
+
+
+class DEP_REQ_RES(object):
+    PDU_SHOW = "{self.PDU_NAME} {self.pfb.FMT_NAME} PNI={self.pfb.pni} "\
+        "DID={self.did} NAD={self.nad} DATA={data}"
+
+    class PFB:
+        def __init__(self, fmt, nad, did, pni):
+            self.fmt, self.nad, self.did, self.pni = fmt, nad, did, pni
+
+        @property
+        def FMT_NAME(self):
+            return {0: "INF", 1: "I++", 4: "ACK", 5: "NAK", 8: "ATN",
+                    9: "TOX"}.get(self.fmt, "{0:04b}".format(self.fmt))
+
+        @property
+        def type(self): return self.fmt
+
+    LastInformation, MoreInformation, PositiveAck, NegativeAck,\
+        Attention, TimeoutExtension = (0, 1, 4, 5, 8, 9)
+
+    def __init__(self, pfb, did, nad, data):
+        self.pfb, self.did, self.nad = pfb, did, nad
+        self.data = bytearray() if data is None else data
+
+    def __str__(self):
+        data = hexlify(self.data).decode()
+        return self.PDU_SHOW.format(self=self, data=data)
+
+    def bytes(self):
+        data = hexlify(self.data)
+        return self.PDU_SHOW.format(self=self, data=data)
+
+    @classmethod
+    def decode(cls, data):
+        if data.startswith(cls.PDU_CODE):
+            del data[0:2]
+            try:
+                pfb = data.pop(0)
+                pfb = cls.PFB(pfb >> 4, bool(pfb & 8), bool(pfb & 4), pfb & 3)
+                did = data.pop(0) if pfb.did else None
+                nad = data.pop(0) if pfb.nad else None
+            except IndexError:
+                errstr = "invalid format of the " + cls.PDU_NAME
+                raise nfc.clf.ProtocolError(errstr)
+            return cls(pfb, did, nad, data)
+
+    def encode(self):
+        pfb = self.pfb
+        pfb = (pfb.fmt << 4) | (pfb.nad << 3) | (pfb.did << 2) | (pfb.pni)
+        data = self.PDU_CODE + struct.pack("B", pfb)
+        if self.pfb.did:
+            data.append(self.did)
+        if self.pfb.nad:
+            data.append(self.nad)
+        return data + self.data
+
+
+class DEP_REQ(DEP_REQ_RES):
+    PDU_CODE = bytearray(b'\xD4\x06')
+    PDU_NAME = 'DEP-REQ'
+
+
+class DEP_RES(DEP_REQ_RES):
+    PDU_CODE = bytearray(b'\xD5\x07')
+    PDU_NAME = 'DEP-RES'
+
+
+class DSL_REQ_RES(object):
+    def __init__(self, did):
+        self.did = did
+
+    def __str__(self):
+        return "{0} DID={1}".format(self.PDU_NAME, self.did)
+
+    @classmethod
+    def decode(cls, data):
+        if data.startswith(cls.PDU_CODE):
+            if len(data) > 3:
+                errstr = "invalid format of the " + cls.PDU_NAME
+                raise nfc.clf.ProtocolError(errstr)
+            return cls(data[2] if len(data) == 3 else None)
+
+    def encode(self):
+        return self.PDU_CODE + (b""
+                                if self.did is None
+                                else struct.pack("B", self.did))
+
+
+class DSL_REQ(DSL_REQ_RES):
+    PDU_CODE = bytearray(b'\xD4\x08')
+    PDU_NAME = 'DSL-REQ'
+
+
+class DSL_RES(DSL_REQ_RES):
+    PDU_CODE = bytearray(b'\xD5\x09')
+    PDU_NAME = 'DSL-RES'
+
+
+class RLS_REQ_RES(DSL_REQ_RES):
+    pass
+
+
+class RLS_REQ(RLS_REQ_RES):
+    PDU_CODE = bytearray(b'\xD4\x0A')
+    PDU_NAME = 'RLS-REQ'
+
+
+class RLS_RES(RLS_REQ_RES):
+    PDU_CODE = bytearray(b'\xD5\x0B')
+    PDU_NAME = 'RLS-RES'

src/lib/nfc/handover/__init__.py

@@ -0,0 +1,29 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2012 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""
+The nfc.handover module implements the NFC Forum Connection Handover
+1.2 protocol as a server and client class that simplify realization of
+handover selector and requester functionality.
+
+"""
+from src.lib.nfc.handover.server import HandoverServer                     # noqa: F401
+from src.lib.nfc.handover.client import HandoverClient                     # noqa: F401

src/lib/nfc/handover/client.py

@@ -0,0 +1,118 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+#
+# Negotiated Connection Handover - Client Base Class
+#
+import binascii
+import logging
+import time
+import ndef
+import src.lib.nfc
+
+
+log = logging.getLogger(__name__)
+
+
+class HandoverClient(object):
+    """ NFC Forum Connection Handover client
+    """
+    def __init__(self, llc):
+        self.socket = None
+        self.llc = llc
+
+    def connect(self, recv_miu=248, recv_buf=2):
+        """Connect to the remote handover server if available. Raises
+        :exc:`nfc.llcp.ConnectRefused` if the remote device does not
+        have a handover service or the service does not accept any
+        more connections."""
+        socket = nfc.llcp.Socket(self.llc, nfc.llcp.DATA_LINK_CONNECTION)
+        socket.setsockopt(nfc.llcp.SO_RCVBUF, recv_buf)
+        socket.setsockopt(nfc.llcp.SO_RCVMIU, recv_miu)
+        socket.connect("urn:nfc:sn:handover")
+        server = socket.getpeername()
+        log.debug("handover client connected to remote sap {0}".format(server))
+        self.socket = socket
+
+    def close(self):
+        """Disconnect from the remote handover server."""
+        if self.socket:
+            self.socket.close()
+            self.socket = None
+
+    def send_records(self, records):
+        """Send handover request message records to the remote server."""
+        log.debug("sending '{0}' message".format(records[0].type))
+        try:
+            octets = b''.join(ndef.message_encoder(records))
+        except ndef.EncodeError as error:
+            log.error(repr(error))
+        else:
+            return self.send_octets(octets)
+
+    def send_octets(self, octets):
+        log.debug(">>> %s", binascii.hexlify(octets).decode())
+        miu = self.socket.getsockopt(nfc.llcp.SO_SNDMIU)
+        while len(octets) > 0:
+            if self.socket.send(octets[0:miu]):
+                octets = octets[miu:]
+            else:
+                break
+        return len(octets) == 0
+
+    def recv_records(self, timeout=None):
+        """Receive a handover select message from the remote server."""
+        octets = self.recv_octets(timeout)
+        records = list(ndef.message_decoder(octets, 'relax')) if octets else []
+        if records and records[0].type == "urn:nfc:wkt:Hs":
+            log.debug("received '{0}' message".format(records[0].type))
+            return list(ndef.message_decoder(octets, 'relax'))
+        else:
+            log.error("received invalid message %s", binascii.hexlify(octets))
+            return []
+
+    def recv_octets(self, timeout=None):
+        octets = bytearray()
+        started = time.time()
+        while self.socket.poll("recv", timeout):
+            try:
+                octets += self.socket.recv()
+            except TypeError:
+                log.debug("data link connection closed")
+                return b''  # recv() returned None
+            try:
+                list(ndef.message_decoder(octets, 'strict', {}))
+                log.debug("<<< %s", binascii.hexlify(octets).decode())
+                return bytes(octets)
+            except ndef.DecodeError:
+                log.debug("message is incomplete (%d byte)", len(octets))
+                if timeout:
+                    timeout -= time.time() - started
+                    started = time.time()
+                    log.debug("%.3f seconds left to timeout", timeout)
+                continue  # incomplete message
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()

src/lib/nfc/handover/server.py

@@ -0,0 +1,128 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+#
+# Negotiated Connection Handover - Server Base Class
+#
+import threading
+import binascii
+import logging
+import errno
+import ndef
+import src.lib.nfc
+
+
+log = logging.getLogger(__name__)
+
+
+class HandoverServer(threading.Thread):
+    """ NFC Forum Connection Handover server
+    """
+    def __init__(self, llc, request_size_limit=0x10000,
+                 recv_miu=1984, recv_buf=15):
+        socket = nfc.llcp.Socket(llc, nfc.llcp.DATA_LINK_CONNECTION)
+        recv_miu = socket.setsockopt(nfc.llcp.SO_RCVMIU, recv_miu)
+        recv_buf = socket.setsockopt(nfc.llcp.SO_RCVBUF, recv_buf)
+        socket.bind('urn:nfc:sn:handover')
+        log.info("handover server bound to port {0} (MIU={1}, RW={2})"
+                 .format(socket.getsockname(), recv_miu, recv_buf))
+        socket.listen(backlog=2)
+        threading.Thread.__init__(self, name='urn:nfc:sn:handover',
+                                  target=self.listen, args=(llc, socket))
+
+    def listen(self, llc, socket):
+        log.debug("handover listen thread started")
+        try:
+            while True:
+                client_socket = socket.accept()
+                client_thread = threading.Thread(target=self.serve,
+                                                 args=(client_socket,))
+                client_thread.start()
+        except nfc.llcp.Error as error:
+            (log.debug if error.errno == errno.EPIPE else log.error)(error)
+        finally:
+            socket.close()
+            log.debug("handover listen thread terminated")
+
+    def serve(self, socket):
+        peer_sap = socket.getpeername()
+        log.info("serving handover client on remote sap {0}".format(peer_sap))
+        send_miu = socket.getsockopt(nfc.llcp.SO_SNDMIU)
+        try:
+            while socket.poll("recv"):
+                request = bytearray()
+                while socket.poll("recv"):
+                    request += socket.recv()
+
+                    if len(request) == 0:
+                        continue  # need some data
+
+                    try:
+                        list(ndef.message_decoder(request, 'strict', {}))
+                    except ndef.DecodeError:
+                        continue  # need more data
+
+                    response = self._process_request_data(request)
+
+                    for offset in range(0, len(response), send_miu):
+                        fragment = response[offset:offset + send_miu]
+                        if not socket.send(fragment):
+                            return  # connection closed
+
+        except nfc.llcp.Error as error:
+            (log.debug if error.errno == errno.EPIPE else log.error)(error)
+        finally:
+            socket.close()
+            log.debug("handover serve thread terminated")
+
+    def _process_request_data(self, octets):
+        log.debug("<<< %s", binascii.hexlify(octets).decode())
+        try:
+            records = list(ndef.message_decoder(octets, 'relax'))
+        except ndef.DecodeError as error:
+            log.error(repr(error))
+            return b''
+
+        if records[0].type == 'urn:nfc:wkt:Hr':
+            records = self.process_handover_request_message(records)
+        else:
+            log.error("received unknown request message")
+            records = []
+
+        octets = b''.join(ndef.message_encoder(records))
+        log.debug(">>> %s", binascii.hexlify(octets).decode())
+        return octets
+
+    def process_handover_request_message(self, records):
+        """Process a handover request message. The *records* argument holds a
+        list of :class:`ndef.Record` objects decoded from the received
+        handover request message octets, where the first record type is
+        ``urn:nfc:wkt:Hr``. The method returns a list of :class:`ndef.Record`
+        objects with the first record typ ``urn:nfc:wkt:Hs``.
+
+        This method should be overwritten by a subclass to customize
+        it's behavior. The default implementation returns a
+        :class:`ndef.HandoverSelectRecord` with version ``1.2`` and no
+        alternative carriers.
+
+        """
+        log.warning("default process_request method should be overwritten")
+        return [ndef.HandoverSelectRecord('1.2')]

src/lib/nfc/llcp/__init__.py

@@ -0,0 +1,38 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""
+The nfc.llcp module implements the NFC Forum Logical Link Control
+Protocol (LLCP) specification and provides a socket interface to use
+the connection-less and connection-mode transport facilities of LLCP.
+"""
+from .socket import Socket                                         # noqa: F401
+from .llc import LOGICAL_DATA_LINK, DATA_LINK_CONNECTION           # noqa: F401
+from .err import Error, ConnectRefused, errno                      # noqa: F401
+
+SO_SNDMIU = 1
+SO_RCVMIU = 2
+SO_SNDBUF = 3
+SO_RCVBUF = 4
+SO_SNDBSY = 5
+SO_RCVBSY = 6
+
+MSG_DONTWAIT = 0b00000001

src/lib/nfc/llcp/err.py

@@ -0,0 +1,42 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 os
+import errno
+
+
+class Error(IOError):
+    def __init__(self, errno):
+        super(Error, self).__init__(errno, os.strerror(errno))
+
+    def __str__(self):
+        return "nfc.llcp.Error: [{0}] {1}".format(
+            errno.errorcode[self.errno], self.strerror)
+
+
+class ConnectRefused(Error):
+    def __init__(self, reason):
+        super(ConnectRefused, self).__init__(errno.ECONNREFUSED)
+        self.reason = reason
+
+    def __str__(self):
+        return "nfc.llcp.ConnectRefused: [{0}] {1} with reason {2}".format(
+            errno.errorcode[self.errno], self.strerror, self.reason)

src/lib/nfc/llcp/llc.py

@@ -0,0 +1,886 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+from . import tco
+from . import pdu
+from . import err
+from . import sec
+import src.lib.nfc.llcp
+import src.lib.nfc.clf
+import src.lib.nfc.dep
+
+import re
+import time
+import errno
+import random
+import threading
+import collections
+
+import logging
+log = logging.getLogger(__name__)
+
+RAW_ACCESS_POINT, LOGICAL_DATA_LINK, DATA_LINK_CONNECTION = range(3)
+
+wks_map = {
+    b"urn:nfc:sn:sdp": 1,
+    b"urn:nfc:sn:snep": 4,
+}
+
+service_name_format = \
+    re.compile(b"^urn:nfc:[x]?sn:[a-zA-Z][a-zA-Z0-9-_:\\.]*$")
+
+
+class ServiceAccessPoint(object):
+    def __init__(self, addr, llc):
+        self.llc = llc
+        self.addr = addr
+        self.sock_list = collections.deque()
+        self.send_list = collections.deque()
+
+    def __str__(self):
+        return "SAP {0:>2}".format(self.addr)
+
+    @property
+    def mode(self):
+        with self.llc.lock:
+            try:
+                if isinstance(self.sock_list[0], tco.RawAccessPoint):
+                    return RAW_ACCESS_POINT
+                if isinstance(self.sock_list[0], tco.LogicalDataLink):
+                    return LOGICAL_DATA_LINK
+                if isinstance(self.sock_list[0], tco.DataLinkConnection):
+                    return DATA_LINK_CONNECTION
+            except IndexError:
+                return 0
+
+    def insert_socket(self, socket):
+        with self.llc.lock:
+            try:
+                insertable = isinstance(socket, type(self.sock_list[0]))
+            except IndexError:
+                insertable = True
+            if insertable:
+                socket.bind(self.addr)
+                self.sock_list.appendleft(socket)
+            else:
+                log.error("can't insert socket of different type")
+            return insertable
+
+    def remove_socket(self, socket):
+        assert socket.addr == self.addr
+        socket.close()
+        with self.llc.lock:
+            try:
+                self.sock_list.remove(socket)
+            except ValueError:
+                pass
+            if len(self.sock_list) == 0:
+                # completely remove this sap
+                self.llc.sap[self.addr] = None
+
+    def send(self, send_pdu):
+        self.send_list.append(send_pdu)
+
+    def shutdown(self):
+        while True:
+            try:
+                socket = self.sock_list.pop()
+            except IndexError:
+                return
+            log.debug("shutdown socket %s" % str(socket))
+            socket.bind(None)
+            socket.close()
+
+    #
+    # enqueue() and dequeue() are called from llc run thread
+    #
+    def enqueue(self, rcvd_pdu):
+        with self.llc.lock:
+            if isinstance(rcvd_pdu, pdu.Connect):
+                for socket in self.sock_list:
+                    if socket.state.LISTEN:
+                        socket.enqueue(rcvd_pdu)
+                        break
+                else:
+                    args = (rcvd_pdu.ssap, rcvd_pdu.dsap, 0x02)
+                    self.send(pdu.DisconnectedMode(*args))
+            else:
+                for socket in self.sock_list:
+                    if rcvd_pdu.ssap == socket.peer or socket.peer is None:
+                        socket.enqueue(rcvd_pdu)
+                        break
+                else:
+                    if rcvd_pdu.name in tco.DataLinkConnection.DLC_PDU_NAMES:
+                        args = (rcvd_pdu.ssap, rcvd_pdu.dsap, 0x01)
+                        self.send(pdu.DisconnectedMode(*args))
+                    else:
+                        log.debug("%s discard PDU %s", self, rcvd_pdu)
+
+    def dequeue(self, miu_size, icv_size):
+        with self.llc.lock:
+            for socket in self.sock_list:
+                send_pdu = socket.dequeue(miu_size, icv_size)
+                if send_pdu:
+                    return send_pdu
+            else:
+                try:
+                    return self.send_list.popleft()
+                except IndexError:
+                    pass
+
+    def sendack(self):
+        with self.llc.lock:
+            for socket in self.sock_list:
+                send_pdu = socket.sendack()
+                if send_pdu:
+                    return send_pdu
+
+
+class ServiceDiscovery(object):
+    def __init__(self, llc):
+        self.llc = llc
+        self.snl = dict()
+        self.tids = list(range(256))
+        self.resp = threading.Condition(self.llc.lock)
+        self.sent = dict()
+        self.sdreq = collections.deque()
+        self.sdres = collections.deque()
+        self.dmpdu = collections.deque()
+
+    def __str__(self):
+        return "SAP  1"
+
+    @property
+    def mode(self):
+        return LOGICAL_DATA_LINK
+
+    def resolve(self, name):
+        with self.resp:
+            if self.snl is None:
+                return None
+            log.debug("resolve service name %r", name)
+            try:
+                return self.snl[name]
+            except KeyError:
+                pass
+            tid = random.choice(self.tids)
+            self.tids.remove(tid)
+            self.sdreq.append((tid, name))
+            while self.snl is not None and name not in self.snl:
+                self.resp.wait()
+            return None if self.snl is None else self.snl[name]
+
+    #
+    # enqueue() and dequeue() are called from llc run thread
+    #
+    def enqueue(self, rcvd_pdu):
+        with self.llc.lock:
+            if ((isinstance(rcvd_pdu, pdu.ServiceNameLookup)
+                 and self.snl is not None)):
+
+                for tid, sap in rcvd_pdu.sdres:
+                    try:
+                        name = self.sent[tid]
+                    except KeyError:
+                        continue
+                    log.debug("resolved %r to remote addr %d", name, sap)
+                    csn, sap = sap >> 6 & 1, sap & 63
+                    if csn:
+                        sap = 1
+                    self.snl[name] = sap
+                    self.tids.append(tid)
+                    self.resp.notify_all()
+
+                for tid, name in rcvd_pdu.sdreq:
+                    try:
+                        sap = self.llc.snl[name]
+                    except KeyError:
+                        sap = 0
+                    self.sdres.append((tid, sap))
+
+    def dequeue(self, miu_size, icv_size):
+        with self.llc.lock:
+            if len(self.sdres) > 0 or len(self.sdreq) > 0:
+                send_pdu = pdu.ServiceNameLookup(dsap=1, ssap=1)
+                # add service discovery responses
+                while miu_size > 0:
+                    try:
+                        send_pdu.sdres.append(self.sdres.popleft())
+                        miu_size -= 4
+                    except IndexError:
+                        break
+                # add service discovery requests
+                for i in range(len(self.sdreq)):
+                    tid, name = self.sdreq[0]
+                    if 3 + len(name) > miu_size:
+                        self.sdreq.rotate(-1)
+                    else:
+                        send_pdu.sdreq.append(self.sdreq.popleft())
+                        self.sent[tid] = name
+                        miu_size -= 3 + len(name)
+                return send_pdu
+            if len(self.dmpdu) > 0 and miu_size > 0:
+                return self.dmpdu.popleft()
+
+    def shutdown(self):
+        with self.llc.lock:
+            self.snl = None
+            self.resp.notify_all()
+
+
+class LogicalLinkController(object):
+    class LinkState(object):
+        def __init__(self):
+            self.names = ("SHUTDOWN", "LISTEN", "CONNECT", "CONNECTED",
+                          "ESTABLISHED", "DISCONNECT", "CLOSED")
+            self.value = self.names.index("SHUTDOWN")
+
+        def __str__(self):
+            return self.names[self.value]
+
+        def __getattr__(self, name):
+            return self.value == self.names.index(name)
+
+        def __setattr__(self, name, value):
+            if name not in ("names", "value"):
+                value, name = self.names.index(name), "value"
+            parent = super(LogicalLinkController.LinkState, self)
+            parent.__setattr__(name, value)
+
+    class Counter(object):
+        def __init__(self):
+            self.sent = collections.defaultdict(int)
+            self.rcvd = collections.defaultdict(int)
+
+        @property
+        def sent_count(self):
+            return sum(self.sent.values())
+
+        @property
+        def rcvd_count(self):
+            return sum(self.rcvd.values())
+
+        def __str__(self):
+            s = "sent/rcvd {0}/{1}".format(self.sent_count, self.rcvd_count)
+            for name in sorted(set(list(self.sent.keys())
+                                   + list(self.rcvd.keys()))):
+                s += " {name} {sent}/{rcvd}".format(
+                    name=name, sent=self.sent[name], rcvd=self.rcvd[name])
+            return s
+
+    def __init__(self, **options):
+        self.pcnt = LogicalLinkController.Counter()
+        self.link = LogicalLinkController.LinkState()
+        self.lock = threading.RLock()
+        self.cfg = dict()
+        self.cfg['recv-miu'] = options.get('miu', 248)
+        self.cfg['send-lto'] = options.get('lto', 500)
+        self.cfg['send-lsc'] = options.get('lsc', 3)
+        self.cfg['send-agf'] = options.get('agf', True)
+        self.cfg['llcp-sec'] = options.get('sec', True)
+        if not sec.OpenSSL:
+            self.cfg['llcp-sec'] = False
+        log.debug("llc cfg {0}".format(self.cfg))
+        self.sec = None
+        self.snl = dict({b"urn:nfc:sn:sdp": 1})
+        self.sap = 64 * [None]
+        self.sap[0] = ServiceAccessPoint(0, self)
+        self.sap[1] = ServiceDiscovery(self)
+
+    def __str__(self):
+        local = "Local(MIU={miu}, LTO={lto}ms)".format(
+            miu=self.cfg.get('recv-miu'), lto=self.cfg.get('send-lto'))
+        remote = "Remote(MIU={miu}, LTO={lto}ms)".format(
+            miu=self.cfg.get('send-miu'), lto=self.cfg.get('recv-lto'))
+        return "LLC: {local} {remote}".format(local=local, remote=remote)
+
+    @property
+    def secure_data_transfer(self):
+        return self.cfg.get('llcp-dpc', 0) == 1
+
+    def activate(self, mac, **options):
+        assert isinstance(mac, (nfc.dep.Initiator, nfc.dep.Target))
+        self.mac = None
+
+        wks = 1 + sum([1 << sap for sap in self.snl.values() if sap < 15])
+
+        send_pax = pdu.ParameterExchange()
+        send_pax.version = (1, 3)
+        send_pax.wks = wks
+        if self.cfg['recv-miu'] != 128:
+            send_pax.miu = self.cfg['recv-miu']
+        if self.cfg['send-lto'] != 100:
+            send_pax.lto = self.cfg['send-lto']
+        if self.cfg['send-lsc'] != 0:
+            send_pax.lsc = self.cfg['send-lsc']
+        if self.cfg['llcp-sec']:
+            send_pax.dpc = 1
+
+        gb = b'Ffm' + pdu.encode(send_pax)[2:]
+        if isinstance(mac, nfc.dep.Initiator):
+            self.link.CONNECT = True
+            gb = mac.activate(gbi=gb, **options)
+            self.run = self.run_as_initiator
+        else:
+            self.link.LISTEN = True
+            gb = mac.activate(gbt=gb, **options)
+            self.run = self.run_as_target
+
+        if gb and gb.startswith(b'Ffm') and len(gb) >= 6:
+            if ((isinstance(mac, nfc.dep.Target)
+                 and mac.rwt >= send_pax.lto * 1E-3)):
+                msg = "local NFC-DEP RWT {0:.3f} contradicts LTO {1:.3f} sec"
+                log.warning(msg.format(mac.rwt, send_pax.lto*1E3))
+
+            rcvd_pax = pdu.decode(b"\x00\x40" + bytes(gb[3:]))
+
+            log.debug("SENT {0}".format(send_pax))
+            log.debug("RCVD {0}".format(rcvd_pax))
+
+            self.cfg['rcvd-ver'] = rcvd_pax.version
+            self.cfg['send-miu'] = rcvd_pax.miu
+            self.cfg['recv-lto'] = rcvd_pax.lto
+            self.cfg['send-wks'] = rcvd_pax.wks
+            self.cfg['send-lsc'] = rcvd_pax.lsc
+            self.cfg['llcp-dpc'] = rcvd_pax.dpc if self.cfg['llcp-sec'] else 0
+            log.debug("llc cfg {0}".format(self.cfg))
+
+            info = '\n'.join([
+                "LLCP Link established as NFC-DEP {role}",
+                "Local LLCP Settings",
+                "  LLCP Version: {send_pax.version_text}",
+                "  Link Timeout: {send_pax.lto} ms",
+                "  Max Inf Unit: {send_pax.miu} octet",
+                "  Link Service: {send_pax.lsc_text}",
+                "  Data Protect: {send_pax.dpc_text}",
+                "  Service List: {send_pax.wks:016b} ({send_pax.wks_text})",
+                "Remote LLCP Settings",
+                "  LLCP Version: {rcvd_pax.version[0]}.{rcvd_pax.version[1]}",
+                "  Link Timeout: {rcvd_pax.lto} ms",
+                "  Max Inf Unit: {rcvd_pax.miu} octet",
+                "  Link Service: {rcvd_pax.lsc_text}",
+                "  Data Protect: {rcvd_pax.dpc_text}",
+                "  Service List: {rcvd_pax.wks:016b} ({rcvd_pax.wks_text})"
+            ]).format(role=mac.role, send_pax=send_pax, rcvd_pax=rcvd_pax)
+            log.info(info)
+
+            if isinstance(mac, nfc.dep.Initiator) and mac.rwt is not None:
+                max_rwt = 4096/13.56E6 * 2**10
+                if mac.rwt > max_rwt:
+                    msg = "remote NFC-DEP RWT {0:.3f} exceeds max {1:.3f} sec"
+                    log.warning(msg.format(mac.rwt, max_rwt))
+
+            self.mac = mac
+            self.link.CONNECTED = True
+
+        return bool(self.mac)
+
+    def terminate(self, reason):
+        log.debug("llcp link termination caused by {0}".format(reason))
+        if type(self.mac) == nfc.dep.Initiator:
+            if self.link.DISCONNECT is True:
+                self.exchange(pdu.Disconnect(0, 0), timeout=0.5)
+            self.mac.deactivate(release=False)  # use DESELECT
+        if type(self.mac) == nfc.dep.Target:
+            self.mac.deactivate(data=bytearray(b"\x01\x40"))
+        # shutdown local services
+        for i in range(63, -1, -1):
+            if not self.sap[i] is None:
+                log.debug("closing service access point %d" % i)
+                self.sap[i].shutdown()
+                self.sap[i] = None
+        self.link.SHUTDOWN = True
+
+    def exchange(self, send_pdu, timeout):
+        # Send and receive one protocol data unit. The send_pdu is
+        # None for the first call when running as target (because the
+        # target first receives a pdu). All PDUs except SYMM are
+        # logged with debug level, SYMM is logged with DEBUG-1 so that
+        # it must be explicitely enabled. The return value is either a
+        # PDU instance or None.
+        try:
+            if send_pdu:
+                loglevel = logging.DEBUG - bool(send_pdu.name == "SYMM")
+                log.log(loglevel, "SEND %s", send_pdu)
+                send_data = pdu.encode(send_pdu)
+                self.pcnt.sent[send_pdu.name] += 1
+                rcvd_data = self.mac.exchange(send_data, timeout)
+            else:
+                rcvd_data = self.mac.exchange(None, timeout)
+            if rcvd_data is not None:
+                rcvd_pdu = pdu.decode(rcvd_data)
+                self.pcnt.rcvd[rcvd_pdu.name] += 1
+                loglevel = logging.DEBUG - bool(rcvd_pdu.name == "SYMM")
+                log.log(loglevel, "RECV %s", rcvd_pdu)
+                return rcvd_pdu
+        except (nfc.clf.CommunicationError, pdu.Error) as error:
+            log.warning("{0!r}".format(error))
+
+    def run_as_initiator(self, terminate=lambda: False):
+        recv_timeout = 1E-3 * (self.cfg['recv-lto'] + 10)
+        msg = "starting initiator run loop with a receive timeout of %.3f sec"
+        log.debug(msg, recv_timeout)
+
+        symm = 0  # counts the number of consecutive SYMM PDUs
+        try:
+            if self.cfg['llcp-dpc'] == 1:
+                cipher = sec.cipher_suite("ECDH_anon_WITH_AEAD_AES_128_CCM_4")
+                pubkey = cipher.public_key_x + cipher.public_key_y
+                random = cipher.random_nonce
+                send_dps = pdu.DataProtectionSetup(0, 0, pubkey, random)
+                rcvd_dps = self.exchange(send_dps, recv_timeout)
+                if not isinstance(rcvd_dps, pdu.DataProtectionSetup):
+                    log.error("expected a DPS PDU response")
+                    return self.terminate(reason="key agreement error")
+                if not (rcvd_dps.ecpk and len(rcvd_dps.ecpk) == 64):
+                    log.error("absent or invalid ECPK parameter in DPS PDU")
+                    return self.terminate(reason="key agreement error")
+                if not (rcvd_dps.rn and len(rcvd_dps.rn) == 8):
+                    log.error("absent or invalid RN parameter in DPS PDU")
+                    return self.terminate(reason="key agreement error")
+                cipher.calculate_session_key(rcvd_dps.ecpk, rn_t=rcvd_dps.rn)
+                self.sec = cipher
+
+            send_pdu = self.collect(delay=0.01)
+            self.link.ESTABLISHED = True
+            while not terminate():
+                if send_pdu is None:
+                    send_pdu = pdu.Symmetry()
+                rcvd_pdu = self.exchange(send_pdu, recv_timeout)
+                if rcvd_pdu is None:
+                    return self.terminate(reason="link disruption")
+                if rcvd_pdu == pdu.Disconnect(0, 0):
+                    self.link.CLOSED = True
+                    return self.terminate(reason="remote choice")
+                symm += 1 if rcvd_pdu.name == "SYMM" else 0
+                self.dispatch(rcvd_pdu)
+                send_pdu = self.collect(delay=0.001)
+                if send_pdu is None and symm >= 10:
+                    send_pdu = self.collect(delay=0.05)
+            else:
+                self.link.DISCONNECT = True
+                self.terminate(reason="local choice")
+        except KeyboardInterrupt:
+            print()  # move to new line
+            self.link.DISCONNECT = True
+            self.terminate(reason="local choice")
+            raise KeyboardInterrupt
+        except IOError:
+            self.terminate(reason="input/output error")
+            raise SystemExit
+        except sec.KeyAgreementError:
+            self.terminate(reason="key agreement error")
+            raise SystemExit
+        except sec.DecryptionError:
+            self.terminate(reason="decryption error")
+            raise SystemExit
+        except sec.EncryptionError:
+            self.terminate(reason="encryption error")
+            raise SystemExit
+        finally:
+            log.debug("llc run loop terminated on initiator")
+
+    def run_as_target(self, terminate=lambda: False):
+        recv_timeout = 1E-3 * (self.cfg['recv-lto'] + 10)
+        msg = "starting target run loop with a receive timeout of %.3f sec"
+        log.debug(msg, recv_timeout)
+
+        symm = 0  # counts the number of consecutive SYMM PDUs
+        try:
+            if self.cfg['llcp-dpc'] == 1:
+                cipher = sec.cipher_suite("ECDH_anon_WITH_AEAD_AES_128_CCM_4")
+                pubkey = cipher.public_key_x + cipher.public_key_y
+                random = cipher.random_nonce
+                send_dps = pdu.DataProtectionSetup(0, 0, pubkey, random)
+                rcvd_dps = self.exchange(None, recv_timeout)
+                if not isinstance(rcvd_dps, pdu.DataProtectionSetup):
+                    log.error("expected a DPS PDU request")
+                    return self.terminate(reason="key agreement error")
+                if not (rcvd_dps.ecpk and len(rcvd_dps.ecpk) == 64):
+                    log.error("absent or invalid ECPK parameter in DPS PDU")
+                    return self.terminate(reason="key agreement error")
+                if not (rcvd_dps.rn and len(rcvd_dps.rn) == 8):
+                    log.error("absent or invalid RN parameter in DPS PDU")
+                    return self.terminate(reason="key agreement error")
+                rcvd_pdu = self.exchange(send_dps, recv_timeout)
+                cipher.calculate_session_key(rcvd_dps.ecpk, rn_i=rcvd_dps.rn)
+                self.sec = cipher
+            else:
+                rcvd_pdu = self.exchange(None, recv_timeout)
+
+            self.link.ESTABLISHED = True
+            while not terminate():
+                if rcvd_pdu is None:
+                    return self.terminate(reason="link disruption")
+                if rcvd_pdu == pdu.Disconnect(0, 0):
+                    self.link.CLOSED = True
+                    return self.terminate(reason="remote choice")
+                symm += 1 if isinstance(rcvd_pdu, pdu.Symmetry) else 0
+                self.dispatch(rcvd_pdu)
+                send_pdu = self.collect(delay=0.001)
+                if send_pdu is None and symm >= 10:
+                    send_pdu = self.collect(delay=0.05)
+                if send_pdu is None:
+                    send_pdu = pdu.Symmetry()
+                rcvd_pdu = self.exchange(send_pdu, recv_timeout)
+            else:
+                self.link.DISCONNECT = True
+                self.terminate(reason="local choice")
+        except KeyboardInterrupt:
+            print()  # move to new line
+            self.link.DISCONNECT = True
+            self.terminate(reason="local choice")
+            raise KeyboardInterrupt
+        except IOError:
+            self.terminate(reason="input/output error")
+            raise SystemExit
+        except sec.KeyAgreementError:
+            self.terminate(reason="key agreement error")
+            raise SystemExit
+        except sec.DecryptionError:
+            self.terminate(reason="decryption error")
+            raise SystemExit
+        except sec.EncryptionError:
+            self.terminate(reason="encryption error")
+            raise SystemExit
+        finally:
+            log.debug("llc run loop terminated on target")
+
+    def collect(self, delay=None):
+        # Collect a single PDU or multiple PDUs if aggregation is enabled.
+        if delay:
+            time.sleep(delay)
+
+        def encrypt(send_pdu):
+            pdu_type = type(send_pdu)
+            a = send_pdu.encode_header()
+            c = self.sec.encrypt(a, send_pdu.data)
+            return pdu_type(*pdu_type.decode_header(a), data=c)
+
+        miu_size = self.cfg["send-miu"]
+        icv_size = self.sec.icv_size if self.sec else 0
+        send_pdu = None
+
+        with self.lock:
+            # Dequeue from the list of active SAP until a first PDU is
+            # returned. The list is sorted to first iterate the raw
+            # SAPs (raw SAPs do not respect the miu_size value and we
+            # must avoid them to return PDUs in aggregation). The PDU
+            # is returned straight if it fills or exceeds the Link
+            # MIU. Otherwise the loop terminates at this point. The
+            # sap.dequeue method is called with icv_size=0 because for
+            # encrypted but not aggregated UI and I PDUs the receiver
+            # must accept them with complete MIU plus ICV size.
+            for sap in sorted(filter(None, self.sap), reverse=True,
+                              key=lambda sap: sap.mode == RAW_ACCESS_POINT):
+                send_pdu = sap.dequeue(miu_size, icv_size=0)
+                if send_pdu:
+                    if self.sec and send_pdu.name in ("UI", "I"):
+                        send_pdu = encrypt(send_pdu)
+                    if len(send_pdu) - send_pdu.header_size >= miu_size:
+                        return send_pdu
+                    break
+
+            # Data Link Connection endpoints do not dequeue RR/RNR PDUs until
+            # the receive window is exhausted. If there is not yet a PDU to
+            # send, this loop allows voluntary acknowledgement.
+            if send_pdu is None:
+                for sap in filter(None, self.sap):
+                    if sap.mode == DATA_LINK_CONNECTION:
+                        send_pdu = sap.sendack()
+                        if send_pdu:
+                            break
+
+            # Finish if either there is either no PDU to send or if PDU
+            # aggregation is disabled.
+            if send_pdu is None or self.cfg['send-agf'] is False:
+                return send_pdu
+
+            # We have one PDU to send and aggregation is enabled. We'll see if
+            # there are more outbound PDUs and collect them into an AGF PDU.
+            agf_pdu = pdu.AggregatedFrame(0, 0, [send_pdu])
+            miu_size = self.cfg["send-miu"] - len(agf_pdu) - 3
+            while True:
+                # The first loop will dequeue PDUs until the reamining miu_size
+                # is exhausted or all active SAP did not return a PDU.
+                deq_none = True
+                for sap in filter(None, self.sap):
+                    send_pdu = sap.dequeue(miu_size, icv_size)
+                    if send_pdu:
+                        deq_none = False
+                        if self.sec and send_pdu.name in ("UI", "I"):
+                            send_pdu = encrypt(send_pdu)
+                        agf_pdu.append(send_pdu)
+                        miu_size = self.cfg["send-miu"] - len(agf_pdu) - 3
+                        if miu_size < 0:
+                            break
+                if miu_size < 0 or deq_none:
+                    break
+            # If the miu_size is not yet exhausted we query all data link
+            # connection endpoints once for voluntary acknowledgements.
+            if miu_size >= 0:
+                for sap in filter(None, self.sap):
+                    if sap.mode == DATA_LINK_CONNECTION:
+                        send_pdu = sap.sendack()
+                        if send_pdu:
+                            agf_pdu.append(send_pdu)
+                            miu_size = self.cfg["send-miu"] - len(agf_pdu) - 3
+                            if miu_size < 0:
+                                break
+
+            return agf_pdu if agf_pdu.count > 1 else agf_pdu.first
+
+    def dispatch(self, rcvd_pdu):
+        if rcvd_pdu is None or rcvd_pdu.name == "SYMM":
+            return
+
+        if rcvd_pdu.name == "AGF":
+            if rcvd_pdu.dsap == 0 and rcvd_pdu.ssap == 0:
+                for p in rcvd_pdu:
+                    log.debug("     " + str(p))
+                for p in rcvd_pdu:
+                    self.dispatch(p)
+            return
+
+        if rcvd_pdu.name == "CONNECT" and rcvd_pdu.dsap == 1:
+            # connect-by-name
+            addr = self.snl.get(rcvd_pdu.sn)
+            if not addr or self.sap[addr] is None:
+                dm_reason = 0x10 if rcvd_pdu.sn is None else 0x02
+                dm_pdu = pdu.DisconnectedMode(rcvd_pdu.ssap, 1, dm_reason)
+                self.sap[1].dmpdu.append(dm_pdu)
+                log.debug("could not find service %r", rcvd_pdu.sn)
+                return
+            # service found, rewrite CONNECT PDU to its DSAP
+            rcvd_pdu = pdu.Connect(dsap=addr, ssap=rcvd_pdu.ssap,
+                                   rw=rcvd_pdu.rw, miu=rcvd_pdu.miu)
+
+        if self.sec and rcvd_pdu.name in ("UI", "I"):
+            pdu_type = type(rcvd_pdu)
+            a = rcvd_pdu.encode_header()
+            p = self.sec.decrypt(a, rcvd_pdu.data)
+            rcvd_pdu = pdu_type(*pdu_type.decode_header(a), data=p)
+
+        with self.lock:
+            sap = self.sap[rcvd_pdu.dsap]
+            if sap:
+                sap.enqueue(rcvd_pdu)
+            else:
+                log.debug("can't dispatch PDU %s", rcvd_pdu)
+
+    def resolve(self, name):
+        if isinstance(name, (bytes, bytearray)):
+            return self.sap[1].resolve(bytes(name))
+        return self.sap[1].resolve(name.encode('latin'))
+
+    def socket(self, socket_type):
+        if socket_type == RAW_ACCESS_POINT:
+            return tco.RawAccessPoint(recv_miu=self.cfg["recv-miu"])
+        if socket_type == LOGICAL_DATA_LINK:
+            return tco.LogicalDataLink(recv_miu=self.cfg["recv-miu"])
+        if socket_type == DATA_LINK_CONNECTION:
+            return tco.DataLinkConnection(recv_miu=128, recv_win=1)
+
+    def setsockopt(self, socket, option, value):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if option == nfc.llcp.SO_RCVMIU:
+            value = min(value, self.cfg['recv-miu'])
+        socket.setsockopt(option, value)
+        return socket.getsockopt(option)
+
+    def getsockopt(self, socket, option):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if isinstance(socket, tco.LogicalDataLink):
+            # FIXME: set socket send miu when activated
+            socket.send_miu = self.cfg['send-miu']
+        if isinstance(socket, tco.RawAccessPoint):
+            # FIXME: set socket send miu when activated
+            socket.send_miu = self.cfg['send-miu']
+        return socket.getsockopt(option)
+
+    def bind(self, socket, addr_or_name=None):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if socket.addr is not None:
+            raise err.Error(errno.EINVAL)
+        if addr_or_name is None:
+            self._bind_by_none(socket)
+        elif isinstance(addr_or_name, int):
+            self._bind_by_addr(socket, addr_or_name)
+        elif isinstance(addr_or_name, (bytes, bytearray)):
+            self._bind_by_name(socket, bytes(addr_or_name))
+        elif isinstance(addr_or_name, str):
+            self._bind_by_name(socket, addr_or_name.encode('latin'))
+        else:
+            raise err.Error(errno.EFAULT)
+
+    def _bind_by_none(self, socket):
+        with self.lock:
+            try:
+                addr = 32 + self.sap[32:64].index(None)
+            except ValueError:
+                raise err.Error(errno.EAGAIN)
+            else:
+                socket.bind(addr)
+                self.sap[addr] = ServiceAccessPoint(addr, self)
+                self.sap[addr].insert_socket(socket)
+
+    def _bind_by_addr(self, socket, addr):
+        if addr < 0 or addr > 63:
+            raise err.Error(errno.EFAULT)
+        with self.lock:
+            if addr in range(32, 64) or isinstance(socket, tco.RawAccessPoint):
+                if self.sap[addr] is None:
+                    socket.bind(addr)
+                    self.sap[addr] = ServiceAccessPoint(addr, self)
+                    self.sap[addr].insert_socket(socket)
+                else:
+                    raise err.Error(errno.EADDRINUSE)
+            else:
+                raise err.Error(errno.EACCES)
+
+    def _bind_by_name(self, socket, name):
+        if not service_name_format.match(name):
+            raise err.Error(errno.EFAULT)
+
+        with self.lock:
+            if self.snl.get(name) is not None:
+                raise err.Error(errno.EADDRINUSE)
+            addr = wks_map.get(name)
+            if addr is None:
+                try:
+                    addr = 16 + self.sap[16:32].index(None)
+                except ValueError:
+                    raise err.Error(errno.EADDRNOTAVAIL)
+            socket.bind(addr)
+            self.sap[addr] = ServiceAccessPoint(addr, self)
+            self.sap[addr].insert_socket(socket)
+            self.snl[name] = addr
+
+    def connect(self, socket, dest):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if not socket.is_bound:
+            self.bind(socket)
+        socket.connect(dest)
+        log.debug("connected ({0} ===> {1})".format(socket.addr, socket.peer))
+        if socket.send_miu > self.cfg['send-miu']:
+            log.warning("reducing outbound miu to not exceed the link miu")
+            socket.send_miu = self.cfg['send-miu']
+
+    def listen(self, socket, backlog):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if not isinstance(socket, tco.DataLinkConnection):
+            raise err.Error(errno.EOPNOTSUPP)
+        if not isinstance(backlog, int):
+            raise TypeError("backlog must be int type")
+        if backlog < 0:
+            raise ValueError("backlog can not be negative")
+        backlog = min(backlog, 16)
+        if not socket.is_bound:
+            self.bind(socket)
+        socket.listen(backlog)
+
+    def accept(self, socket):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if not isinstance(socket, tco.DataLinkConnection):
+            raise err.Error(errno.EOPNOTSUPP)
+        while True:
+            client = socket.accept()
+            self.sap[client.addr].insert_socket(client)
+            log.debug("new data link connection ({0} <=== {1})"
+                      .format(client.addr, client.peer))
+            if client.send_miu > self.cfg['send-miu']:
+                log.warning("reducing outbound miu to comply with link miu")
+                client.send_miu = self.cfg['send-miu']
+            return client
+
+    def send(self, socket, message, flags):
+        return self.sendto(socket, message, socket.peer, flags)
+
+    def sendto(self, socket, message, dest, flags):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if isinstance(socket, tco.RawAccessPoint):
+            if not isinstance(message, pdu.ProtocolDataUnit):
+                raise TypeError("on a raw access point message must be a pdu")
+            if not socket.is_bound:
+                self.bind(socket)
+            # FIXME: set socket send miu when activated
+            socket.send_miu = self.cfg['send-miu']
+            return socket.send(message, flags)
+        if not isinstance(message, (bytes, bytearray)):
+            raise TypeError("message data must be a bytes-like object")
+        if isinstance(socket, tco.LogicalDataLink):
+            if dest is None:
+                raise err.Error(errno.EDESTADDRREQ)
+            if not socket.is_bound:
+                self.bind(socket)
+            # FIXME: set socket send miu when activated
+            socket.send_miu = self.cfg['send-miu']
+            return socket.sendto(message, dest, flags)
+        if isinstance(socket, tco.DataLinkConnection):
+            return socket.send(message, flags)
+
+    def recv(self, socket):
+        message, sender = self.recvfrom(socket)
+        return message
+
+    def recvfrom(self, socket):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if not (socket.addr and self.sap[socket.addr]):
+            raise err.Error(errno.EBADF)
+        if isinstance(socket, tco.RawAccessPoint):
+            return (socket.recv(), None)
+        if isinstance(socket, tco.LogicalDataLink):
+            return socket.recvfrom()
+        if isinstance(socket, tco.DataLinkConnection):
+            return (socket.recv(), socket.peer)
+
+    def poll(self, socket, event, timeout=None):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if not (socket.addr and self.sap[socket.addr]):
+            raise err.Error(errno.EBADF)
+        return socket.poll(event, timeout)
+
+    def close(self, socket):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        if socket.is_bound:
+            self.sap[socket.addr].remove_socket(socket)
+        else:
+            socket.close()
+
+    def getsockname(self, socket):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        return socket.addr
+
+    def getpeername(self, socket):
+        if not isinstance(socket, tco.TransmissionControlObject):
+            raise err.Error(errno.ENOTSOCK)
+        return socket.peer

src/lib/nfc/llcp/pdu.py

@@ -0,0 +1,945 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 struct
+from binascii import hexlify
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Error(Exception):
+    pass
+
+
+class DecodeError(Error):
+    pass
+
+
+class EncodeError(Error):
+    pass
+
+
+class Parameter:
+    VERSION, MIUX, WKS, LTO, RW, SN, OPT, SDREQ, SDRES, ECPK, RN = range(1, 12)
+
+    @staticmethod
+    def decode(data, offset):
+        try:
+            T, L = struct.unpack_from('BB', data, offset)
+            V = struct.unpack_from('%ds' % L, data, offset+2)[0]
+        except struct.error as error:
+            msg = " while decoding TLV %r" % hexlify(data[offset:])
+            raise DecodeError(str(error) + msg)
+
+        if T == Parameter.VERSION:
+            if L != 1:
+                raise DecodeError("VERSION TLV length error")
+            V = struct.unpack('B', V)[0]
+        elif T == Parameter.MIUX:
+            if L != 2:
+                raise DecodeError("MIUX TLV length error")
+            V = struct.unpack('>H', V)[0]
+            if V & 0xF800:
+                log.warning("MIUX TLV reserved bits set")
+                V = V & 0x07FF
+        elif T == Parameter.WKS:
+            if L != 2:
+                raise DecodeError("WKS TLV length error")
+            V = struct.unpack('>H', V)[0]
+        elif T == Parameter.LTO:
+            if L != 1:
+                raise DecodeError("LTO TLV length error")
+            V = struct.unpack('B', V)[0]
+        elif T == Parameter.RW:
+            if L != 1:
+                raise DecodeError("RW TLV length error")
+            V = struct.unpack('B', V)[0]
+            if V & 0xF0:
+                log.warning("RW TLV reserved bits set")
+                V = V & 0x0F
+        elif T == Parameter.SN and L == 0:
+            log.warning("SN TLV with zero-length service name")
+        elif T == Parameter.OPT:
+            if L != 1:
+                raise DecodeError("OPT TLV length error")
+            V = struct.unpack_from('B', V)[0]
+            if V & 0xF8:
+                log.warning("OPT TLV reserved bits set")
+                V = V & 0x07
+        elif T == Parameter.SDREQ:
+            if L == 0:
+                raise DecodeError("SDREQ TLV length error")
+            if L == 1:
+                log.warning("SDREQ TLV with zero-length service name")
+            V = struct.unpack('B%ds' % (L-1), V)
+        elif T == Parameter.SDRES:
+            if L != 2:
+                raise DecodeError("SDRES TLV length error")
+            V = struct.unpack('BB', V)
+        elif T == Parameter.ECPK:
+            if L == 0:
+                log.warning("ECPK TLV with zero-length value")
+            if L & 1:
+                log.warning("ECPK TLV with odd length value")
+        elif T == Parameter.RN:
+            if L == 0:
+                log.warning("RN TLV with zero-length value")
+
+        return (T, L, V)
+
+    @staticmethod
+    def encode(T, V):
+        try:
+            if T in (Parameter.VERSION, Parameter.LTO,
+                     Parameter.RW, Parameter.OPT):
+                return struct.pack('BBB', T, 1, V)
+            if T in (Parameter.MIUX, Parameter.WKS):
+                return struct.pack('>BBH', T, 2, V)
+            if T in (Parameter.SN, Parameter.ECPK, Parameter.RN):
+                if len(V) > 255:
+                    raise EncodeError("can't encode TLV T=%d, V=%r" % (T, V))
+                return struct.pack('BB', T, len(V)) + bytes(V)
+            if T == Parameter.SDREQ:
+                tid, sn = V[0], V[1]
+                if len(sn) > 254:
+                    raise EncodeError("can't encode TLV T=%d, V=%r" % (T, V))
+                return struct.pack('>BBB', T, 1+len(sn), tid) + bytes(sn)
+            if T == Parameter.SDRES:
+                tid, sap = V[0], V[1]
+                return struct.pack('>BBBB', T, 2, tid, sap)
+            raise EncodeError("unknown TLV T=%d, V=%r" % (T, V))
+        except struct.error as error:
+            msg = " for TLV T=%d, V=%r" % (T, V)
+            raise EncodeError(str(error) + msg)
+
+
+# -----------------------------------------------------------------------------
+#                                                   ProtocolDataUnit Base Class
+# -----------------------------------------------------------------------------
+class ProtocolDataUnit(object):
+    header_size = 2
+
+    def __init__(self, ptype, dsap, ssap):
+        self.ptype = ptype
+        self.dsap = dsap
+        self.ssap = ssap
+
+    @classmethod
+    def decode_header(cls, data, offset=0, size=None):
+        if size is None:
+            size = len(data) - offset
+        if size < cls.header_size:
+            raise DecodeError("insufficient pdu header bytes")
+        (dsap, ssap) = struct.unpack_from('!BB', data, offset)
+        return (dsap >> 2, ssap & 63)
+
+    def encode_header(self):
+        if self.dsap is None or self.ssap is None:
+            raise EncodeError("pdu dsap and ssap field can not be None")
+        if self.dsap < 0 or self.ssap < 0:
+            raise EncodeError("pdu dsap and ssap field can not be < 0")
+        if self.dsap > 63 or self.ssap > 63:
+            raise EncodeError("pdu dsap and ssap field can not be > 63")
+        return struct.pack('!H', self.dsap << 10 | self.ptype << 6 | self.ssap)
+
+    def __eq__(self, other):
+        return self.encode() == other.encode()
+
+    def __str__(self):
+        string = "{pdu.ssap:2} -> {pdu.dsap:2} {pdu.name:4.4s}"
+        return string.format(pdu=self)
+
+
+# -----------------------------------------------------------------------------
+#                                           NumberedProtocolDataUnit Base Class
+# -----------------------------------------------------------------------------
+class NumberedProtocolDataUnit(ProtocolDataUnit):
+    header_size = 3
+
+    def __init__(self, ptype, dsap, ssap, ns, nr):
+        super(NumberedProtocolDataUnit, self).__init__(ptype, dsap, ssap)
+        self.ns, self.nr = ns, nr
+
+    @classmethod
+    def decode_header(cls, data, offset=0, size=None):
+        if size is None:
+            size = len(data) - offset
+        if size < cls.header_size:
+            raise DecodeError("numbered pdu header length error")
+        (dsap, ssap, sequence) = struct.unpack_from('!BBB', data, offset)
+        return (dsap >> 2, ssap & 63, sequence >> 4, sequence & 15)
+
+    def encode_header(self):
+        data = super(NumberedProtocolDataUnit, self).encode_header()
+        if self.ns is None or self.nr is None:
+            raise EncodeError("pdu ns and nr field can not be None")
+        if self.ns < 0 or self.nr < 0:
+            raise EncodeError("pdu ns and nr field can not be < 0")
+        if self.ns > 15 or self.nr > 15:
+            raise EncodeError("pdu ns and nr field can not be > 15")
+        return data + struct.pack('!B', self.ns << 4 | self.nr)
+
+    def __len__(self):
+        return 3
+
+    def __str__(self):
+        f = " N(R)={p.nr}" if self.ns is None else " N(S)={p.ns} N(R)={p.nr}"
+        return super(NumberedProtocolDataUnit, self).__str__()+f.format(p=self)
+
+
+# -----------------------------------------------------------------------------
+#                                                                  Symmetry PDU
+# -----------------------------------------------------------------------------
+class Symmetry(ProtocolDataUnit):
+    name = "SYMM"
+
+    def __init__(self, dsap=0, ssap=0):
+        super(Symmetry, self).__init__(0b0000, dsap, ssap)
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        if dsap != 0 or ssap != 0:
+            raise DecodeError("SSAP and DSAP must be 0 in SYMM PDU")
+        if size >= 3:
+            raise DecodeError("SYMM PDU PAYLOAD must be empty")
+        return Symmetry(dsap, ssap)
+
+    def encode(self):
+        if self.dsap != 0 or self.ssap != 0:
+            raise EncodeError("SSAP and DSAP must be 0 in SYMM PDU")
+        return self.encode_header()
+
+    def __len__(self):
+        return 2
+
+    def __str__(self):
+        return super(Symmetry, self).__str__()
+
+
+# -----------------------------------------------------------------------------
+#                                                        Parameter Exchange PDU
+# -----------------------------------------------------------------------------
+class ParameterExchange(ProtocolDataUnit):
+    name = "PAX"
+
+    def __init__(self, dsap=0, ssap=0, version=None, miux=None,
+                 wks=None, lto=None, opt=None):
+        super(ParameterExchange, self).__init__(0b0001, dsap, ssap)
+        self._version = version
+        self._miux = miux
+        self._wks = wks
+        self._lto = lto
+        self._opt = opt
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        if dsap != 0 or ssap != 0:
+            raise DecodeError("SSAP and DSAP must be 0 in PAX PDU")
+        pax_pdu = ParameterExchange(dsap, ssap)
+        offset, size = offset + 2, size - 2
+        while size >= 2:
+            T, L, V = Parameter.decode(data, offset)
+            if T == Parameter.VERSION:
+                pax_pdu._version = V
+            elif T == Parameter.MIUX:
+                pax_pdu._miux = V
+            elif T == Parameter.WKS:
+                pax_pdu._wks = V
+            elif T == Parameter.LTO:
+                pax_pdu._lto = V
+            elif T == Parameter.OPT:
+                pax_pdu._opt = V
+            else:
+                log.warning("invalid TLV %r in PAX PDU", (T, L, V))
+            offset, size = offset + 2 + L, size - 2 - L
+        return pax_pdu
+
+    def encode(self):
+        if self.dsap != 0 or self.ssap != 0:
+            raise EncodeError("SSAP and DSAP must be 0 in PAX PDU")
+        data = self.encode_header()
+        if self._version is not None:
+            data += Parameter.encode(Parameter.VERSION, self._version)
+        if self._miux is not None:
+            data += Parameter.encode(Parameter.MIUX, self._miux)
+        if self._wks is not None:
+            data += Parameter.encode(Parameter.WKS, self._wks)
+        if self._lto is not None:
+            data += Parameter.encode(Parameter.LTO, self._lto)
+        if self._opt is not None:
+            data += Parameter.encode(Parameter.OPT, self._opt)
+        return data
+
+    def __len__(self):
+        return (2 +
+                (3 if self._version is not None else 0) +
+                (4 if self._miux is not None else 0) +
+                (4 if self._wks is not None else 0) +
+                (3 if self._lto is not None else 0) +
+                (3 if self._opt is not None else 0))
+
+    @property
+    def version(self):
+        version = self._version
+        return (version >> 4, version & 15) if version else (0, 0)
+
+    @version.setter
+    def version(self, value):
+        self._version = (value[0] << 4 & 0xF0) | (value[1] & 0x0F)
+
+    @property
+    def version_text(self):
+        return "{0}.{1}".format(*self.version)
+
+    @property
+    def miu(self):
+        return self._miux + 128 if self._miux is not None else 128
+
+    @miu.setter
+    def miu(self, value):
+        self._miux = max(value - 128, 0)
+
+    @property
+    def wks(self):
+        return self._wks if self._wks is not None else 0
+
+    @wks.setter
+    def wks(self, value):
+        self._wks = value & 0xFFFF
+
+    @property
+    def wks_text(self):
+        t = {0: "LLC", 1: "SDP", 4: "SNEP"}
+        return ', '.join([
+            t.get(i, str(i)) for i in range(15, -1, -1) if self.wks >> i & 1])
+
+    @property
+    def lto(self):
+        return (self._lto if self._lto is not None else 10) * 10
+
+    @lto.setter
+    def lto(self, value):
+        self._lto = (value // 10) & 0xFF
+
+    @property
+    def lsc(self):
+        return self._opt & 3 if self._opt is not None else 0
+
+    @lsc.setter
+    def lsc(self, value):
+        self._opt = ((self._opt or 0) & 0b11111100) | (value & 0b00000011)
+
+    @property
+    def lsc_text(self):
+        return ("link service class unknown at activation",
+                "connection-less link service only",
+                "connection-oriented link service only",
+                "connection-less and connection-oriented")[self.lsc]
+
+    @property
+    def dpc(self):
+        return self._opt >> 2 & 1 if self._opt is not None else 0
+
+    @dpc.setter
+    def dpc(self, value):
+        self._opt = ((self._opt or 0) & 0b11111011) | (bool(value) << 2)
+
+    @property
+    def dpc_text(self):
+        return ("secure data transfer mode not supported",
+                "secure data transfer mode is supported")[self.dpc]
+
+    def __str__(self):
+        s = super(ParameterExchange, self).__str__()
+        if self._version is not None:
+            s += " VER={0}.{1}".format(*self.version)
+        if self._wks is not None:
+            s += " WKS={0:016b}".format(self._wks)
+        if self._miux is not None:
+            s += " MIUX={0}".format(self._miux)
+        if self._lto is not None:
+            s += " LTO={0}".format(self._lto)
+        if self._opt is not None:
+            s += " OPT={0:08b}".format(self._opt)
+        return s
+
+
+# -----------------------------------------------------------------------------
+#                                                          Aggregated Frame PDU
+# -----------------------------------------------------------------------------
+class AggregatedFrame(ProtocolDataUnit):
+    name = "AGF"
+
+    def __init__(self, dsap=0, ssap=0, aggregate=[]):
+        super(AggregatedFrame, self).__init__(0b0010, dsap, ssap)
+        self._aggregate = aggregate[:]
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        if dsap != 0 or ssap != 0:
+            raise DecodeError("SSAP and DSAP must be 0 in AGF PDU")
+        agf_pdu = AggregatedFrame(dsap, ssap)
+        offset, size = offset + 2, size - 2
+        while size > 0:
+            try:
+                (pdu_size,) = struct.unpack_from('!H', data, offset)
+            except struct.error:
+                raise DecodeError("aggregated PDU length field error in AGF")
+            agf_pdu.append(decode(data, offset+2, pdu_size))
+            offset, size = offset + 2 + pdu_size, size - 2 - pdu_size
+        return agf_pdu
+
+    def encode(self):
+        if self.dsap != 0 or self.ssap != 0:
+            raise EncodeError("SSAP and DSAP must be 0 in AGF PDU")
+        data = self.encode_header()
+        for encoded_pdu in [pdu.encode() for pdu in self._aggregate]:
+            data += struct.pack('!H', len(encoded_pdu)) + encoded_pdu
+        return data
+
+    def append(self, pdu):
+        self._aggregate.append(pdu)
+
+    @property
+    def count(self):
+        return len(self._aggregate)
+
+    @property
+    def first(self):
+        return self._aggregate[0]
+
+    def __len__(self):
+        return 2 + sum([2+len(pdu) for pdu in self._aggregate])
+
+    def __str__(self):
+        def s(p):
+            return "LEN={0} '".format(len(p)) + \
+                ProtocolDataUnit.__str__(p).rstrip() + "'"
+        return super(AggregatedFrame, self).__str__() + \
+            " LEN={0} [".format(len(self)-2) + \
+            " ".join([s(p) for p in self._aggregate]) + "]"
+
+    def __iter__(self):
+        return AggregatedFrameIterator(self._aggregate)
+
+
+class AggregatedFrameIterator(object):
+    def __init__(self, aggregate):
+        self._aggregate = aggregate
+        self._current = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._current == len(self._aggregate):
+            raise StopIteration
+        self._current += 1
+        return self._aggregate[self._current-1]
+
+    def next(self):
+        return self.__next__()
+
+
+# -----------------------------------------------------------------------------
+#                                                    Unnumbered Information PDU
+# -----------------------------------------------------------------------------
+class UnnumberedInformation(ProtocolDataUnit):
+    name = "UI"
+
+    def __init__(self, dsap, ssap, data=None):
+        super(UnnumberedInformation, self).__init__(0b0011, dsap, ssap)
+        self.data = data if data else b''
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        payload = bytes(data[offset+2:offset+size])
+        return UnnumberedInformation(dsap, ssap, payload)
+
+    def encode(self):
+        return self.encode_header() + bytes(self.data)
+
+    def __len__(self):
+        return 2 + len(self.data)
+
+    def __str__(self):
+        return super(UnnumberedInformation, self).__str__() + \
+            " LEN={0} DATA={1}".format(len(self.data), hexlify(self.data))
+
+
+# -----------------------------------------------------------------------------
+#                                                                   Connect PDU
+# -----------------------------------------------------------------------------
+class Connect(ProtocolDataUnit):
+    name = "CONNECT"
+
+    def __init__(self, dsap, ssap, miu=128, rw=1, sn=None):
+        super(Connect, self).__init__(0b0100, dsap, ssap)
+        self.miu = miu
+        self.rw = rw
+        self.sn = sn
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        connect_pdu = Connect(dsap, ssap)
+        offset, size = offset + 2, size - 2
+        while size >= 2:
+            T, L, V = Parameter.decode(data, offset)
+            if T == Parameter.MIUX:
+                connect_pdu.miu = 128 + V
+            elif T == Parameter.RW:
+                connect_pdu.rw = V
+            elif T == Parameter.SN:
+                connect_pdu.sn = V
+            else:
+                log.warning("invalid TLV %r in CONNECT PDU", (T, L, V))
+            offset, size = offset + 2 + L, size - 2 - L
+        return connect_pdu
+
+    def encode(self):
+        data = self.encode_header()
+        if self.miu and self.miu > 128:
+            data += Parameter.encode(Parameter.MIUX, self.miu - 128)
+        if self.rw and self.rw != 1:
+            data += Parameter.encode(Parameter.RW, self.rw)
+        if self.sn:
+            data += Parameter.encode(Parameter.SN, self.sn)
+        return data
+
+    def __len__(self):
+        return (2 +
+                (4 if self.miu and self.miu > 128 else 0) +
+                (3 if self.rw and self.rw != 1 else 0) +
+                (2 + len(self.sn) if self.sn else 0))
+
+    def __str__(self):
+        s = " MIU={conn.miu} RW={conn.rw} SN={conn.sn}"
+        return super(Connect, self).__str__() + s.format(conn=self)
+
+
+# -----------------------------------------------------------------------------
+#                                                                Disconnect PDU
+# -----------------------------------------------------------------------------
+class Disconnect(ProtocolDataUnit):
+    name = "DISC"
+
+    def __init__(self, dsap, ssap):
+        super(Disconnect, self).__init__(0b0101, dsap, ssap)
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        return Disconnect(dsap, ssap)
+
+    def encode(self):
+        return self.encode_header()
+
+    def __len__(self):
+        return 2
+
+    def __str__(self):
+        return super(Disconnect, self).__str__()
+
+
+# -----------------------------------------------------------------------------
+#                                                       Connection Complete PDU
+# -----------------------------------------------------------------------------
+class ConnectionComplete(ProtocolDataUnit):
+    name = "CC"
+
+    def __init__(self, dsap, ssap, miu=128, rw=1):
+        super(ConnectionComplete, self).__init__(0b0110, dsap, ssap)
+        self.miu = miu
+        self.rw = rw
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        cc_pdu = ConnectionComplete(dsap, ssap)
+        offset, size = offset + 2, size - 2
+        while size >= 2:
+            T, L, V = Parameter.decode(data, offset)
+            if T == Parameter.MIUX:
+                cc_pdu.miu = 128 + V
+            elif T == Parameter.RW:
+                cc_pdu.rw = V
+            else:
+                log.warning("invalid TLV %r in CC PDU", (T, L, V))
+            offset, size = offset + 2 + L, size - 2 - L
+        return cc_pdu
+
+    def encode(self):
+        data = self.encode_header()
+        if self.miu and self.miu > 128:
+            data += Parameter.encode(Parameter.MIUX, self.miu - 128)
+        if self.rw and self.rw != 1:
+            data += Parameter.encode(Parameter.RW, self.rw)
+        return data
+
+    def __len__(self):
+        return (2 +
+                (4 if self.miu and self.miu > 128 else 0) +
+                (3 if self.rw and self.rw != 1 else 0))
+
+    def __str__(self):
+        return super(ConnectionComplete, self).__str__() + \
+            " MIU={cc.miu} RW={cc.rw}".format(cc=self)
+
+
+# -----------------------------------------------------------------------------
+#                                                         Disconnected Mode PDU
+# -----------------------------------------------------------------------------
+class DisconnectedMode(ProtocolDataUnit):
+    name = "DM"
+
+    def __init__(self, dsap, ssap, reason=0):
+        super(DisconnectedMode, self).__init__(0b0111, dsap, ssap)
+        self.reason = reason
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        if size != 3:
+            raise DecodeError("DM PDU length error")
+        dsap, ssap = cls.decode_header(data, offset, size)
+        (reason,) = struct.unpack_from('!B', data, offset+2)
+        return DisconnectedMode(dsap, ssap, reason)
+
+    def encode(self):
+        return self.encode_header() + struct.pack('!B', self.reason)
+
+    def __len__(self):
+        return 3
+
+    def __str__(self):
+        return super(DisconnectedMode, self).__str__() + \
+            " REASON={dm.reason:02x}h".format(dm=self)
+
+    @property
+    def reason_text(self):
+        return {
+            0x00: "disconnected",
+            0x01: "inactive",
+            0x02: "unbound",
+            0x03: "rejected",
+            0x10: "permanent reject for sap",
+            0x11: "permanent reject for any",
+            0x20: "temporary reject for sap",
+            0x21: "temporary reject for any",
+        }.get(self.reason, "{0:02x}h".format(self.reason))
+
+
+# -----------------------------------------------------------------------------
+#                                                              Frame Reject PDU
+# -----------------------------------------------------------------------------
+class FrameReject(ProtocolDataUnit):
+    name = "FRMR"
+
+    def __init__(self, dsap, ssap, flags=0, ptype=0,
+                 ns=0, nr=0, vs=0, vr=0, vsa=0, vra=0):
+        super(FrameReject, self).__init__(0b1000, dsap, ssap)
+        self.rej_flags = flags
+        self.rej_ptype = ptype
+        self.ns = ns
+        self.nr = nr
+        self.vs = vs
+        self.vr = vr
+        self.vsa = vsa
+        self.vra = vra
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        if size != 6:
+            raise DecodeError("FRMR PDU length error")
+        dsap, ssap = cls.decode_header(data, offset, size)
+        (b0, b1, b2, b3) = struct.unpack_from('!BBBB', data, offset+2)
+        flags, ptype = b0 >> 4, b0 & 15
+        ns, nr = b1 >> 4, b1 & 15
+        vs, vr = b2 >> 4, b2 & 15
+        vsa, vra = b3 >> 4, b3 & 15
+        return FrameReject(dsap, ssap, flags, ptype, ns, nr, vs, vr, vsa, vra)
+
+    @staticmethod
+    def from_pdu(pdu, flags, dlc):
+        rej_ptype = pdu.ptype
+        rej_flags = sum([1 << "SRIW".index(f) for f in flags])
+        frmr = FrameReject(pdu.ssap, pdu.dsap, rej_flags, rej_ptype)
+        if isinstance(pdu, Information):
+            frmr.ns, frmr.nr = pdu.ns, pdu.nr
+        if isinstance(pdu, ReceiveReady) or isinstance(pdu, ReceiveNotReady):
+            frmr.nr = pdu.nr
+        frmr.vs, frmr.vsa = dlc.send_cnt, dlc.send_ack
+        frmr.vr, frmr.vra = dlc.recv_cnt, dlc.recv_ack
+        return frmr
+
+    def encode(self):
+        return self.encode_header() + struct.pack(
+            '!BBBB', self.rej_flags << 4 | self.rej_ptype,
+            self.ns << 4 | self.nr, self.vs << 4 | self.vr,
+            self.vsa << 4 | self.vra)
+
+    def __len__(self):
+        return 6
+
+    def __str__(self):
+        return super(FrameReject, self).__str__() +\
+            " FLAGS={frmr.rej_flags:04b} PTYPE={frmr.rej_ptype:04b}"\
+            " N(S)={frmr.ns} N(R)={frmr.nr}"\
+            " V(S)={frmr.vs} V(R)={frmr.vr}"\
+            " V(SA)={frmr.vsa} V(RA)={frmr.vra}"\
+            .format(frmr=self)
+
+
+# -----------------------------------------------------------------------------
+#                                                       Service Name Lookup PDU
+# -----------------------------------------------------------------------------
+class ServiceNameLookup(ProtocolDataUnit):
+    name = "SNL"
+
+    def __init__(self, dsap, ssap, sdreq=None, sdres=None):
+        super(ServiceNameLookup, self).__init__(0b1001, dsap, ssap)
+        self.sdreq = sdreq if sdreq else list()
+        self.sdres = sdres if sdres else list()
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        if dsap != 1 or ssap != 1:
+            raise DecodeError("SSAP and DSAP must be 1 in SNL PDU")
+        snl_pdu = ServiceNameLookup(dsap, ssap)
+        offset, size = offset + 2, size - 2
+        while size >= 2:
+            T, L, V = Parameter.decode(data, offset)
+            if T == Parameter.SDREQ:
+                snl_pdu.sdreq.append(V)
+            elif T == Parameter.SDRES:
+                snl_pdu.sdres.append(V)
+            else:
+                log.warning("invalid TLV %r in SNL PDU", (T, L, V))
+            offset, size = offset + 2 + L, size - 2 - L
+        return snl_pdu
+
+    def encode(self):
+        data = self.encode_header()
+        for sdreq in self.sdreq:
+            data += Parameter.encode(Parameter.SDREQ, sdreq)
+        for sdres in self.sdres:
+            data += Parameter.encode(Parameter.SDRES, sdres)
+        return data
+
+    def __len__(self):
+        return 2 + (len(self.sdres) * 4) \
+            + sum([3+len(sdreq[1]) for sdreq in self.sdreq])
+
+    def __str__(self):
+        return super(ServiceNameLookup, self).__str__() + \
+            " SDRES={0} SDREQ={1}".format(str(self.sdres), str(self.sdreq))
+
+
+# -----------------------------------------------------------------------------
+#                                                     Data Protection Setup PDU
+# -----------------------------------------------------------------------------
+class DataProtectionSetup(ProtocolDataUnit):
+    name = "DPS"
+
+    def __init__(self, dsap, ssap, ecpk=None, rn=None):
+        super(DataProtectionSetup, self).__init__(0b1010, dsap, ssap)
+        self.ecpk = ecpk
+        self.rn = rn
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        if dsap != 0 or ssap != 0:
+            raise DecodeError("SSAP and DSAP must be 0 in DPS PDU")
+        dps_pdu = DataProtectionSetup(dsap, ssap)
+        offset, size = offset + 2, size - 2
+        while size >= 2:
+            T, L, V = Parameter.decode(data, offset)
+            if T == Parameter.ECPK:
+                dps_pdu.ecpk = V
+            elif T == Parameter.RN:
+                dps_pdu.rn = V
+            else:
+                log.debug("unknown TLV %r in DPS PDU", (T, L, V))
+            offset, size = offset + 2 + L, size - 2 - L
+        return dps_pdu
+
+    def encode(self):
+        if self.dsap != 0 or self.ssap != 0:
+            raise EncodeError("SSAP and DSAP must be 0 in DPS PDU")
+        data = self.encode_header()
+        if self.ecpk:
+            data += Parameter.encode(Parameter.ECPK, self.ecpk)
+        if self.rn:
+            data += Parameter.encode(Parameter.RN, self.rn)
+        return data
+
+    def __len__(self):
+        return (2 +
+                (2 + len(self.ecpk) if self.ecpk else 0) +
+                (2 + len(self.rn) if self.rn else 0))
+
+    def __str__(self):
+        return super(DataProtectionSetup, self).__str__() + \
+            " ECPK={0} RN={1}".format(
+                'None' if self.ecpk is None else hexlify(self.ecpk).decode(),
+                'None' if self.rn is None else hexlify(self.rn).decode())
+
+
+# -----------------------------------------------------------------------------
+#                                                               Information PDU
+# -----------------------------------------------------------------------------
+class Information(NumberedProtocolDataUnit):
+    name = "I"
+
+    def __init__(self, dsap, ssap, ns=None, nr=None, data=None):
+        super(Information, self).__init__(0b1100, dsap, ssap, ns, nr)
+        self.data = data if data else b''
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap, ns, nr = cls.decode_header(data, offset, size)
+        payload = bytes(data[offset+3:offset+size])
+        return cls(dsap, ssap, ns, nr, payload)
+
+    def encode(self):
+        return self.encode_header() + bytes(self.data)
+
+    def __len__(self):
+        return 3 + len(self.data)
+
+    def __str__(self):
+        return (super(Information, self).__str__() + " LEN={0} DATA={1}"
+                .format(len(self.data), hexlify(self.data)))
+
+
+# -----------------------------------------------------------------------------
+#                                                             Receive Ready PDU
+# -----------------------------------------------------------------------------
+class ReceiveReady(NumberedProtocolDataUnit):
+    name = "RR"
+
+    def __init__(self, dsap, ssap, nr=None):
+        super(ReceiveReady, self).__init__(0b1101, dsap, ssap, 0, nr)
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap, ns, nr = cls.decode_header(data, offset, size)
+        if ns != 0:
+            log.warning("reserved bits set in sequence field")
+        return cls(dsap, ssap, nr)
+
+    def encode(self):
+        return self.encode_header()
+
+
+# -----------------------------------------------------------------------------
+#                                                         Receive Not Ready PDU
+# -----------------------------------------------------------------------------
+class ReceiveNotReady(NumberedProtocolDataUnit):
+    name = "RNR"
+
+    def __init__(self, dsap, ssap, nr):
+        super(ReceiveNotReady, self).__init__(0b1110, dsap, ssap, 0, nr)
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap, ns, nr = cls.decode_header(data, offset, size)
+        if ns != 0:
+            log.warning("reserved bits set in sequence field")
+        return cls(dsap, ssap, nr)
+
+    def encode(self):
+        return self.encode_header()
+
+
+# -----------------------------------------------------------------------------
+#                                                       UnknownProtocolDataUnit
+# -----------------------------------------------------------------------------
+class UnknownProtocolDataUnit(ProtocolDataUnit):
+    def __init__(self, ptype, dsap, ssap, payload):
+        super(UnknownProtocolDataUnit, self).__init__(ptype, dsap, ssap)
+        self.name = "{0:04b}".format(ptype)
+        self.payload = payload
+
+    @classmethod
+    def decode(cls, data, offset, size):
+        dsap, ssap = cls.decode_header(data, offset, size)
+        pdutype = (data[offset] << 2 | data[offset+1] >> 6) & 0x0F
+        payload = data[offset+2:offset+size]
+        return cls(pdutype, dsap, ssap, payload)
+
+    def encode(self):
+        return self.encode_header() + bytes(self.payload)
+
+    def __len__(self):
+        return 2 + len(self.payload)
+
+    def __str__(self):
+        return (super(UnknownProtocolDataUnit, self).__str__()
+                + " PAYLOAD={}".format(hexlify(self.payload).decode()))
+
+
+# -----------------------------------------------------------------------------
+# pdu decode and encode functions
+# -----------------------------------------------------------------------------
+pdu_type_map = {
+    0b0000: Symmetry,
+    0b0001: ParameterExchange,
+    0b0010: AggregatedFrame,
+    0b0011: UnnumberedInformation,
+    0b0100: Connect,
+    0b0101: Disconnect,
+    0b0110: ConnectionComplete,
+    0b0111: DisconnectedMode,
+    0b1000: FrameReject,
+    0b1001: ServiceNameLookup,
+    0b1010: DataProtectionSetup,
+    0b1100: Information,
+    0b1101: ReceiveReady,
+    0b1110: ReceiveNotReady,
+}
+
+
+def decode(data, offset=0, size=None):
+    size = len(data) if size is None else size
+
+    if offset + size > len(data):
+        raise DecodeError("size bytes from offset exceed the data length")
+    if size < 2:
+        raise DecodeError("less than two header bytes can't make a valid pdu")
+
+    ptype = (struct.unpack_from('>H', data, offset)[0] >> 6) & 0b1111
+    pdu_type = pdu_type_map.get(ptype, UnknownProtocolDataUnit)
+    return pdu_type.decode(data, offset, size)
+
+
+def encode(pdu):
+    if not isinstance(pdu, ProtocolDataUnit):
+        raise AttributeError("can't encode %s" % type(pdu))
+
+    return pdu.encode()

src/lib/nfc/llcp/sec.py

@@ -0,0 +1,542 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 struct
+import ctypes
+import ctypes.util
+from ctypes import c_void_p, c_int
+from binascii import hexlify
+
+import logging
+log = logging.getLogger(__name__)
+
+OpenSSL = None
+
+
+class Error(Exception):
+    pass
+
+
+class EncryptionError(Error):
+    pass
+
+
+class DecryptionError(Error):
+    pass
+
+
+class KeyAgreementError(Error):
+    pass
+
+
+def cipher_suite(name):
+    if name == "ECDH_anon_WITH_AEAD_AES_128_CCM_4":
+        return CipherSuite1()
+
+
+class CipherSuite1:
+    _ccm_t = 4
+    _ccm_q = 2
+    _ccm_n = 13
+
+    def __init__(self):
+        self.random_nonce = None
+        self.public_key_x = None
+        self.public_key_y = None
+        ec_key = OpenSSL.EC_KEY.new_by_curve_name(OpenSSL.NID_X9_62_prime256v1)
+        if ec_key and ec_key.generate_key() and ec_key.check_key():
+            pubkey = ec_key.get_public_key()
+            x, y = pubkey.get_affine_coordinates_GFp(ec_key.get_group())
+            self.public_key_x = x
+            self.public_key_y = y
+            self.random_nonce = OpenSSL.rand_bytes(8)
+            self._ec_key = ec_key
+
+    def calculate_session_key(self, ecpk, rn_i=None, rn_t=None):
+        if ecpk is None:
+            raise KeyAgreementError("remote public key is required")
+        if len(ecpk) != 64:
+            raise KeyAgreementError("remote public key has wrong size")
+        if rn_i is None and rn_t is None:
+            raise KeyAgreementError("remote random nonce is required")
+        if rn_i and len(rn_i) != 8:
+            raise KeyAgreementError("initiator random nonce has wrong size")
+        if rn_t and len(rn_t) != 8:
+            raise KeyAgreementError("target random nonce has wrong size")
+
+        if rn_i is None:
+            rn_i = self.random_nonce
+        if rn_t is None:
+            rn_t = self.random_nonce
+
+        ec_key = OpenSSL.EC_KEY.new_by_curve_name(OpenSSL.NID_X9_62_prime256v1)
+        try:
+            ec_key.set_public_key_affine_coordinates(ecpk[:32], ecpk[32:])
+        except AssertionError:
+            raise KeyAgreementError("remote public key is not on curve")
+
+        cipher = OpenSSL.EVP_aes_128_cbc()
+        secret = OpenSSL.ECDH(self._ec_key) \
+                        .compute_key(ec_key.get_public_key())
+        k_encr = OpenSSL.CMAC(cipher) \
+                        .init(rn_i+rn_t) \
+                        .update(secret).final()
+
+        log.debug("remote ecpk-x %r", hexlify(ecpk[:32]))
+        log.debug("remote ecpk-y %r", hexlify(ecpk[32:]))
+        log.debug("shared secret %r", hexlify(secret))
+        log.debug("shared nonce  %r", hexlify(rn_i+rn_t))
+        log.debug("session key   %r", hexlify(k_encr))
+
+        self._pcs = self._pcr = 0
+        self._k_encr = k_encr
+        return self._k_encr
+
+    @property
+    def icv_size(self):
+        return self._ccm_t
+
+    def encrypt(self, a, p):
+        # The nonce N is a leftmost 40-bit fixed part all bits zero
+        # and a rightmost 64-bit counter part taken from PC(S).
+        nonce = struct.pack('!xxxxxQ', self._pcs)
+        if self._pcs < 0xFFFFFFFFFFFFFFFF:
+            self._pcs += 1
+        else:
+            raise EncryptionError("send counter out of range")
+
+        # The encryption key was computed in calculate_session_key()
+        key = self._k_encr
+
+        # OpenSSLWrapper methods raise AssertionError when any of the
+        # operations failed.
+        try:
+            return self._encrypt(bytes(a), bytes(p), key, nonce, self._ccm_t)
+        except AssertionError:
+            error = "encrypt failed for message %d" % self._pcs
+            log.error(error)
+            raise EncryptionError(error)
+
+    @staticmethod
+    def _encrypt(aad, txt, key, nonce, tlen):
+        # from https://wiki.openssl.org/index.php/
+        # EVP_Authenticated_Encryption_and_Decryption#
+        # Authenticated_Encryption_using_CCM_mode
+        evp = OpenSSL.EVP()
+        evp.encrypt_init(OpenSSL.EVP_aes_128_ccm())
+        evp.cipher_ctx.ctrl_set(OpenSSL.EVP.CTRL_CCM_SET_IVLEN, len(nonce))
+        evp.cipher_ctx.ctrl_set(OpenSSL.EVP.CTRL_CCM_SET_TAG, tlen)
+        evp.encrypt_init(key=key, iv=nonce)
+        evp.encrypt_update(None, None, len(txt))
+        evp.encrypt_update(None, aad, len(aad))
+        return evp.encrypt_update(len(txt), txt, len(txt)) + \
+            evp.cipher_ctx.ctrl_get(OpenSSL.EVP.CTRL_CCM_GET_TAG, tlen)
+
+    def decrypt(self, a, c):
+        # The nonce N is a leftmost 40-bit fixed part all bits zero
+        # and a rightmost 64-bit counter part taken from PC(R).
+        nonce = struct.pack('!xxxxxQ', self._pcr)
+        if self._pcr < 0xFFFFFFFFFFFFFFFF:
+            self._pcr += 1
+        else:
+            raise DecryptionError("recv counter out of range")
+
+        # The decryption key was computed in calculate_session_key()
+        key = self._k_encr
+
+        # OpenSSLWrapper methods raise AssertionError when any of the
+        # operations failed.
+        try:
+            return self._decrypt(bytes(a), bytes(c), key, nonce, self._ccm_t)
+        except AssertionError:
+            error = "decrypt failed for message %d" % self._pcr
+            log.error(error)
+            raise DecryptionError(error)
+
+    @staticmethod
+    def _decrypt(aad, txt, key, nonce, tlen):
+        # from https://wiki.openssl.org/index.php/
+        # EVP_Authenticated_Encryption_and_Decryption#
+        # Authenticated_Decryption_using_CCM_mode
+        tag = txt[-tlen:]
+        txt = txt[:-tlen]
+        evp = OpenSSL.EVP()
+        evp.decrypt_init(OpenSSL.EVP_aes_128_ccm())
+        evp.cipher_ctx.ctrl_set(OpenSSL.EVP.CTRL_CCM_SET_IVLEN, len(nonce))
+        evp.cipher_ctx.ctrl_set(OpenSSL.EVP.CTRL_CCM_SET_TAG, len(tag), tag)
+        evp.decrypt_init(key=key, iv=nonce)
+        evp.decrypt_update(None, None, len(txt))
+        evp.decrypt_update(None, aad, len(aad))
+        return evp.decrypt_update(len(txt), txt, len(txt))
+
+
+class OpenSSLWrapper:
+    NID_X9_62_prime256v1 = 415  # NIST Curve P-256
+
+    def __init__(self, libcrypto):
+        self.crypto = ctypes.CDLL(libcrypto)
+        self.crypto.BN_new.restype = c_void_p
+        self.crypto.BN_num_bits.restype = c_int
+        self.crypto.BN_bn2bin.restype = c_int
+        self.crypto.BN_bin2bn.restype = c_void_p
+        self.crypto.BN_free.restype = None
+        self.crypto.RAND_bytes.restype = c_int
+        self.crypto.EC_KEY_new_by_curve_name.restype = c_void_p
+        self.crypto.EC_KEY_generate_key.restype = c_int
+        self.crypto.EC_KEY_check_key.restype = c_int
+        self.crypto.EC_KEY_set_public_key.restype = c_int
+        self.crypto.EC_KEY_set_public_key_affine_coordinates.restype = c_int
+        self.crypto.EC_KEY_get0_public_key.restype = c_void_p
+        self.crypto.EC_KEY_get0_group.restype = c_void_p
+        self.crypto.EC_KEY_free.restype = None
+        self.crypto.EC_POINT_new.restype = c_void_p
+        self.crypto.EC_POINT_get_affine_coordinates_GFp.restype = c_int
+        self.crypto.EC_POINT_set_affine_coordinates_GFp.restype = c_int
+        self.crypto.EC_POINT_free.restype = None
+        self.crypto.ECDH_OpenSSL.restype = c_void_p
+        self.crypto.ECDH_set_method.restype = c_int
+        self.crypto.ECDH_compute_key.restype = c_int
+        self.crypto.CMAC_CTX_new.restype = c_void_p
+        self.crypto.CMAC_CTX_free.restype = None
+        self.crypto.CMAC_Init.restype = c_int
+        self.crypto.CMAC_Update.restype = c_int
+        self.crypto.CMAC_Final.restype = c_int
+
+        self.crypto.EVP_CIPHER_CTX_new.restype = c_void_p
+        self.crypto.EVP_CIPHER_CTX_init.restype = None
+        self.crypto.EVP_CIPHER_CTX_ctrl.restype = c_int
+        self.crypto.EVP_CIPHER_CTX_free.restype = None
+
+        self.crypto.EVP_EncryptInit_ex.restype = c_int
+        self.crypto.EVP_EncryptUpdate.restype = c_int
+        self.crypto.EVP_EncryptFinal.restype = c_int
+        self.crypto.EVP_DecryptInit_ex.restype = c_int
+        self.crypto.EVP_DecryptUpdate.restype = c_int
+        self.crypto.EVP_DecryptFinal.restype = c_int
+
+        self.crypto.EVP_aes_128_cbc.restype = c_void_p
+        self.crypto.EVP_aes_128_cbc.argtypes = []
+        self.crypto.EVP_aes_128_ccm.restype = c_void_p
+        self.crypto.EVP_aes_128_ccm.argtypes = []
+
+        self.EVP_aes_128_cbc = self.crypto.EVP_aes_128_cbc
+        self.EVP_aes_128_ccm = self.crypto.EVP_aes_128_ccm
+
+    class BIGNUM:
+        def __init__(self, bignum, release=False):
+            self._bignum = bignum
+            self._release = release
+
+        def __del__(self):
+            if self._release:
+                OpenSSL.crypto.BN_free(self)
+
+        @property
+        def _as_parameter_(self):
+            return c_void_p(self._bignum)
+
+        @staticmethod
+        def new():
+            # BIGNUM *BN_new(void);
+            bignum = OpenSSL.crypto.BN_new()
+            if bignum is None:
+                log.error("BN_new")
+            else:
+                return OpenSSL.BIGNUM(bignum, release=True)
+
+        def num_bits(self):
+            return OpenSSL.crypto.BN_num_bits(self)
+
+        def num_bytes(self):
+            return (self.num_bits() + 7) // 8
+
+        def bn2bin(self, num_bytes=None):
+            # int BN_bn2bin(const BIGNUM *a, unsigned char *to);
+            if num_bytes is None:
+                num_bytes = self.num_bytes()
+            else:
+                assert num_bytes >= self.num_bytes(), "bn2bin num bytes"
+            strbuf = ctypes.create_string_buffer(num_bytes)
+            OpenSSL.crypto.BN_bn2bin(self, strbuf)
+            return strbuf.raw
+
+        @staticmethod
+        def bin2bn(s):
+            # BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+            strbuf = ctypes.create_string_buffer(bytes(s), len(s))
+            res = OpenSSL.crypto.BN_bin2bn(strbuf, len(s), None)
+            if res is None:
+                log.error("BN_bin2bn")
+            else:
+                return OpenSSL.BIGNUM(res)
+
+    def rand_bytes(self, num):
+        # int RAND_bytes(unsigned char *buf, int num);
+        buf = ctypes.create_string_buffer(num)
+        res = self.crypto.RAND_bytes(buf, c_int(num))
+        if res == 0:
+            log.error("RAND_bytes")
+        else:
+            return buf.raw
+
+    class EC_KEY:
+        def __init__(self, ec_key):
+            self._ec_key = ec_key
+
+        def __del__(self):
+            OpenSSL.crypto.EC_KEY_free(self)
+
+        @property
+        def _as_parameter_(self):
+            return c_void_p(self._ec_key)
+
+        @staticmethod
+        def new_by_curve_name(nid):
+            # EC_KEY *EC_KEY_new_by_curve_name(int nid);
+            res = OpenSSL.crypto.EC_KEY_new_by_curve_name(c_int(nid))
+            if res is None:
+                log.error("EC_KEY_new_by_curve_name")
+            else:
+                return OpenSSL.EC_KEY(res)
+
+        def generate_key(self):
+            # int EC_KEY_generate_key(EC_KEY *key);
+            res = OpenSSL.crypto.EC_KEY_generate_key(self)
+            if res == 0:
+                log.error("EC_KEY_generate_key")
+            return bool(res)
+
+        def check_key(self):
+            # int EC_KEY_check_key(const EC_KEY *key);
+            res = OpenSSL.crypto.EC_KEY_check_key(self)
+            if res == 0:
+                log.error("EC_KEY_check_key")
+            return bool(res)
+
+        def set_public_key_affine_coordinates(self, pubkey_x, pubkey_y):
+            # int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key,
+            #     BIGNUM *x, BIGNUM *y);
+            r = OpenSSL.crypto.EC_KEY_set_public_key_affine_coordinates(
+                self, *list(map(OpenSSL.BIGNUM.bin2bn, (pubkey_x, pubkey_y))))
+            if r != 1:
+                errmsg = "EC_KEY_set_public_key_affine_coordinates"
+                raise AssertionError(errmsg)
+
+        def get_public_key(self):
+            # const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key);
+            res = OpenSSL.crypto.EC_KEY_get0_public_key(self)
+            if res is None:
+                log.error("EC_KEY_get0_public_key")
+            else:
+                return OpenSSL.EC_POINT(res)
+
+        def get_group(self):
+            # const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key);
+            res = OpenSSL.crypto.EC_KEY_get0_group(self)
+            if res is None:
+                log.error("EC_KEY_get0_group")
+            else:
+                return OpenSSL.EC_GROUP(res)
+
+    class EC_GROUP:
+        def __init__(self, ec_group):
+            self._ec_group = ec_group
+
+        @property
+        def _as_parameter_(self):
+            return c_void_p(self._ec_group)
+
+    class EC_POINT:
+        def __init__(self, ec_point):
+            self._ec_point = ec_point
+
+        @property
+        def _as_parameter_(self):
+            return c_void_p(self._ec_point)
+
+        def get_affine_coordinates_GFp(self, ec_group):
+            # int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group,
+            #     const EC_POINT *p, BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
+            x, y = (OpenSSL.BIGNUM.new(), OpenSSL.BIGNUM.new())
+            func = OpenSSL.crypto.EC_POINT_get_affine_coordinates_GFp
+            res = func(ec_group, self, x, y, None)
+            if res == 0:
+                log.error("EC_POINT_get_affine_coordinates_GFp")
+            else:
+                return (x.bn2bin(32), y.bn2bin(32))
+
+    class ECDH:
+        def __init__(self, local_key):
+            self.key = local_key
+            method = OpenSSL.crypto.ECDH_OpenSSL()
+            OpenSSL.crypto.ECDH_set_method(self.key, c_void_p(method))
+
+        def compute_key(self, pub_key):
+            # int ECDH_compute_key(void *out, size_t outlen,
+            #     const EC_POINT *pub_key, EC_KEY *ecdh,
+            #     void *(*KDF)(const void *in, size_t inlen,
+            #          void *out, size_t *outlen));
+            strbuf = ctypes.create_string_buffer(32)
+            args = (strbuf, 32, pub_key, self.key, None)
+            r = OpenSSL.crypto.ECDH_compute_key(*args)
+            assert r == 32, "ECDH_compute_key"
+            return strbuf.raw  # the shared secret z
+
+    class CMAC:
+        def __init__(self, cipher):
+            # CMAC_CTX *CMAC_CTX_new(void);
+            self._cmac_ctx = OpenSSL.crypto.CMAC_CTX_new()
+            self._cipher = cipher
+
+        def __del__(self):
+            # void CMAC_CTX_free(CMAC_CTX *ctx);
+            OpenSSL.crypto.CMAC_CTX_free(self)
+
+        @property
+        def _as_parameter_(self):
+            return c_void_p(self._cmac_ctx)
+
+        def init(self, key):
+            # int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen,
+            #     const EVP_CIPHER *cipher, ENGINE *impl);
+            assert len(key) == 16
+            keybuf = ctypes.create_string_buffer(key, 16)
+            keylen = ctypes.c_size_t(16)
+            cipher = ctypes.c_void_p(self._cipher)
+            r = OpenSSL.crypto.CMAC_Init(self, keybuf, keylen, cipher, None)
+            assert r == 1, "CMAC_Init"
+            return self
+
+        def update(self, msg):
+            # int CMAC_Update(CMAC_CTX *ctx, const void *data, size_t dlen);
+            msgbuf = ctypes.create_string_buffer(msg, len(msg))
+            msglen = ctypes.c_size_t(len(msg))
+            r = OpenSSL.crypto.CMAC_Update(self, msgbuf, msglen)
+            assert r == 1, "CMAC_Update"
+            return self
+
+        def final(self):
+            macbuf = ctypes.create_string_buffer(16)
+            maclen = ctypes.c_size_t(0)
+            rc = OpenSSL.crypto.CMAC_Final(self, macbuf, ctypes.byref(maclen))
+            assert rc == 1 and maclen.value == 16, "CMAC_Final"
+            return macbuf.raw
+
+    class EVP:
+        CTRL_CCM_SET_IVLEN = 0x09
+        CTRL_CCM_GET_TAG = 0x10
+        CTRL_CCM_SET_TAG = 0x11
+        CTRL_CCM_SET_L = 0x14
+
+        class CIPHER_CTX:
+            def __init__(self):
+                # EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
+                ctx = OpenSSL.crypto.EVP_CIPHER_CTX_new()
+                if ctx is None:
+                    raise AssertionError("EVP_CIPHER_CTX_new")
+                self._ctx = ctx
+
+            def __del__(self):
+                # void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx);
+                OpenSSL.crypto.EVP_CIPHER_CTX_free(self)
+
+            @property
+            def _as_parameter_(self):
+                return c_void_p(self._ctx)
+
+            def ctrl_set(self, op, arg, ptr=None):
+                # int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type,
+                #                         int arg, void *ptr);
+                r = OpenSSL.crypto.EVP_CIPHER_CTX_ctrl(self, op, arg, ptr)
+                if r != 1:
+                    raise AssertionError("EVP_CIPHER_CTX_ctrl")
+
+            def ctrl_get(self, op, arg):
+                # int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type,
+                #                         int arg, void *ptr);
+                outbuf = ctypes.create_string_buffer(arg)
+                r = OpenSSL.crypto.EVP_CIPHER_CTX_ctrl(self, op, arg, outbuf)
+                if r != 1:
+                    raise AssertionError("EVP_CIPHER_CTX_ctrl")
+                return outbuf.raw
+
+        def __init__(self, evp_cipher_ctx=None):
+            if evp_cipher_ctx:
+                self._ctx = evp_cipher_ctx
+            else:
+                self._ctx = OpenSSL.EVP.CIPHER_CTX()
+
+        @property
+        def cipher_ctx(self):
+            return self._ctx
+
+        def encrypt_init(self, evp_cipher=None, key=None, iv=None):
+            # int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,
+            #     const EVP_CIPHER *type, ENGINE *impl,
+            #     unsigned char *key, unsigned char *iv);
+            r = OpenSSL.crypto.EVP_EncryptInit_ex(
+                self._ctx, c_void_p(evp_cipher), None, key, iv)
+            if r != 1:
+                raise AssertionError("EVP_EncryptInit_ex")
+
+        def encrypt_update(self, out_len, message, msg_len):
+            # int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+            #     int *outl, unsigned char *in, int inl);
+            if out_len is None:
+                out_buf = None
+                out_len = c_int(0)
+            else:
+                out_buf = ctypes.create_string_buffer(out_len)
+                out_len = c_int(out_len)
+            r = OpenSSL.crypto.EVP_EncryptUpdate(
+                self._ctx, out_buf, ctypes.byref(out_len), message, msg_len)
+            if r != 1:
+                raise AssertionError("EVP_EncryptUpdate")
+            return out_buf.raw[0:out_len.value] if out_buf else b''
+
+        def decrypt_init(self, evp_cipher=None, key=None, iv=None):
+            # int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,
+            #     const EVP_CIPHER *type, ENGINE *impl,
+            #     unsigned char *key, unsigned char *iv);
+            r = OpenSSL.crypto.EVP_DecryptInit_ex(
+                self._ctx, c_void_p(evp_cipher), None, key, iv)
+            if r != 1:
+                raise AssertionError("EVP_DecryptInit_ex")
+
+        def decrypt_update(self, out_len, message, msg_len):
+            # int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+            #     int *outl, unsigned char *in, int inl);
+            if out_len is None:
+                out_buf = None
+                out_len = c_int(0)
+            else:
+                out_buf = ctypes.create_string_buffer(out_len)
+                out_len = c_int(out_len)
+            r = OpenSSL.crypto.EVP_DecryptUpdate(
+                self._ctx, out_buf, ctypes.byref(out_len), message, msg_len)
+            if r != 1:
+                raise AssertionError("EVP_DecryptUpdate")
+            return out_buf.raw[0:out_len.value] if out_buf else b''
+
+
+libcrypto = ctypes.util.find_library('crypto.so.1.0')
+if libcrypto is not None:
+    OpenSSL = OpenSSLWrapper(libcrypto)

src/lib/nfc/llcp/socket.py

@@ -0,0 +1,177 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+
+
+class Socket(object):
+    """
+    Create a new LLCP socket with the given socket type. The
+    socket type should be one of:
+
+    * :const:`nfc.llcp.LOGICAL_DATA_LINK` for best-effort
+      communication using LLCP connection-less PDU exchange
+
+    * :const:`nfc.llcp.DATA_LINK_CONNECTION` for reliable
+      communication using LLCP connection-mode PDU exchange
+
+    * :const:`nfc.llcp.llc.RAW_ACCESS_POINT` for unregulated LLCP PDU
+      exchange (useful to implement test programs)
+    """
+    def __init__(self, llc, sock_type):
+        self._tco = None if sock_type is None else llc.socket(sock_type)
+        self._llc = llc
+
+    @property
+    def llc(self):
+        """The :class:`~nfc.llcp..llc.LogicalLinkController` instance
+        to which this socket belongs. This attribute is read-only."""
+        return self._llc
+
+    def resolve(self, name):
+        """Resolve a service name into an address. This may involve
+        conversation with the remote service discovery component if
+        the name is hasn't yet been resolved. The return value is the
+        service access point address for the service name bound at the
+        remote device. The address value 0 indicates that the remote
+        device does not have a service with the requested name. The
+        address value 1 indicates that the remote device has a data
+        link connection service with the requested name that can only
+        be connected by service name. The return value is None when
+        communication with the peer device terminated while waiting
+        for a response.
+
+        """
+        return self.llc.resolve(name)
+
+    def setsockopt(self, option, value):
+        """Set the value of the given socket option and return the
+        current value which may have been corrected if it was out of
+        bounds."""
+        return self.llc.setsockopt(self._tco, option, value)
+
+    def getsockopt(self, option):
+        """Return the value of the given socket option."""
+        return self.llc.getsockopt(self._tco, option)
+
+    def bind(self, address=None):
+        """Bind the socket to address. The socket must not already be
+        bound. The address may be a service name string, a service
+        access point number, or it may be omitted. If address is a
+        well-known service name the socket will be bound to the
+        corresponding service access point address, otherwise the
+        socket will be bound to the next available service access
+        point address between 16 and 31 (inclusively). If address is a
+        number between 32 and 63 (inclusively) the socket will be
+        bound to that service access point address. If the address
+        argument is omitted the socket will be bound to the next
+        available service access point address between 32 and 63."""
+        return self.llc.bind(self._tco, address)
+
+    def connect(self, address):
+        """Connect to a remote socket at address. Address may be a
+        service name string or a service access point number."""
+        return self.llc.connect(self._tco, address)
+
+    def listen(self, backlog):
+        """Mark a socket as a socket that will be used to accept
+        incoming connection requests using accept(). The *backlog*
+        defines the maximum length to which the queue of pending
+        connections for the socket may grow. A backlog of zero
+        disables queuing of connection requests.
+        """
+        return self.llc.listen(self._tco, backlog)
+
+    def accept(self):
+        """Accept a connection. The socket must be bound to an address
+        and listening for connections. The return value is a new
+        socket object usable to send and receive data on the
+        connection."""
+        socket = Socket(self._llc, None)
+        socket._tco = self.llc.accept(self._tco)
+        return socket
+
+    def send(self, data, flags=0):
+        """Send data to the socket. The socket must be connected to a remote
+        socket. Returns a boolean value that indicates success or
+        failure. A false value is typically an indication that the
+        socket or connection was closed.
+
+        """
+        return self.llc.send(self._tco, data, flags)
+
+    def sendto(self, data, addr, flags=0):
+        """Send data to the socket. The socket should not be connected
+        to a remote socket, since the destination socket is specified
+        by addr. Returns a boolean value that indicates success
+        or failure. Failure to send is generally an indication that
+        the socket was closed."""
+        return self.llc.sendto(self._tco, data, addr, flags)
+
+    def recv(self):
+        """Receive data from the socket. The return value is a bytes object
+        representing the data received. The maximum amount of data
+        that may be returned is determined by the link or connection
+        maximum information unit size."""
+        return self.llc.recv(self._tco)
+
+    def recvfrom(self):
+        """Receive data from the socket. The return value is a pair
+        (bytes, address) where string is a string representing the
+        data received and address is the address of the socket sending
+        the data."""
+        return self.llc.recvfrom(self._tco)
+
+    def poll(self, event, timeout=None):
+        """Wait for a socket event. Posssible *event* values are the strings
+        "recv", "send" and "acks". Whent the timeout is present and
+        not :const:`None`, it should be a floating point number
+        specifying the timeout for the operation in seconds (or
+        fractions thereof). For "recv" or "send" the :meth:`poll`
+        method returns :const:`True` if a next :meth:`recv` or
+        :meth:`send` operation would be non-blocking. The "acks" event
+        may only be used with a data-link-connection type socket; the
+        call then returns :const:`True` if the counter of received
+        acknowledgements was greater than zero and decrements the
+        counter by one.
+
+        """
+        return self.llc.poll(self._tco, event, timeout)
+
+    def getsockname(self):
+        """Obtain the address to which the socket is bound. For an
+        unbound socket the returned value is None.
+        """
+        return self.llc.getsockname(self._tco)
+
+    def getpeername(self):
+        """Obtain the address of the peer connected on the socket. For
+        an unconnected socket the returned value is None.
+        """
+        return self.llc.getpeername(self._tco)
+
+    def close(self):
+        """Close the socket. All future operations on the socket
+        object will fail. The remote end will receive no more data
+        Sockets are automatically closed when the logical link
+        controller terminates (gracefully or by link disruption). A
+        connection-mode socket will attempt to disconnect the data
+        link connection (if in connected state)."""
+        return self.llc.close(self._tco)

src/lib/nfc/llcp/tco.py

@@ -0,0 +1,733 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+from . import pdu
+from . import err
+import src.lib.nfc.llcp
+
+import errno
+import threading
+import collections
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class TransmissionControlObject(object):
+    class State(object):
+        def __init__(self):
+            self.names = ("SHUTDOWN", "CLOSED", "LISTEN", "CONNECT",
+                          "ESTABLISHED", "DISCONNECT", "CLOSE_WAIT")
+            self.value = self.names.index("SHUTDOWN")
+
+        def __str__(self):
+            return self.names[self.value]
+
+        def __getattr__(self, name):
+            return self.value == self.names.index(name)
+
+        def __setattr__(self, name, value):
+            if name not in ("names", "value"):
+                value, name = self.names.index(name), "value"
+            object.__setattr__(self, name, value)
+
+    class Mode(object):
+        def __init__(self):
+            self.names = ("BLOCK", "SEND_BUSY", "RECV_BUSY", "RECV_BUSY_SENT")
+            self.value = dict([(name, False) for name in self.names])
+
+        def __str__(self):
+            return str(self.value)
+
+        def __getattr__(self, name):
+            return self.value[name]
+
+    def __init__(self, send_miu, recv_miu):
+        self.lock = threading.RLock()
+        self.mode = TransmissionControlObject.Mode()
+        self.state = TransmissionControlObject.State()
+        self.send_queue = collections.deque()
+        self.recv_queue = collections.deque()
+        self.send_ready = threading.Condition(self.lock)
+        self.recv_ready = threading.Condition(self.lock)
+        self.recv_miu = recv_miu
+        self.send_miu = send_miu
+        self.recv_buf = 1
+        self.send_buf = 1
+        self.addr = None
+        self.peer = None
+
+    @property
+    def is_bound(self):
+        return self.addr is not None
+
+    def setsockopt(self, option, value):
+        if option == nfc.llcp.SO_SNDBUF:
+            # with self.lock: self.send_buf = int(value)
+            # adjustable send buffer only with non-blocking socket mode
+            raise NotImplementedError("SO_SNDBUF can not be set")
+        elif option == nfc.llcp.SO_RCVBUF:
+            with self.lock:
+                self.recv_buf = int(value)
+        else:
+            raise ValueError("invalid option value")
+
+    def getsockopt(self, option):
+        if option == nfc.llcp.SO_SNDMIU:
+            return self.send_miu
+        if option == nfc.llcp.SO_RCVMIU:
+            return self.recv_miu
+        if option == nfc.llcp.SO_SNDBUF:
+            return self.send_buf
+        if option == nfc.llcp.SO_RCVBUF:
+            return self.recv_buf
+
+    def bind(self, addr):
+        if self.addr and addr and self.addr != addr:
+            log.warning("socket rebound from {} to {}".format(self.addr, addr))
+        self.addr = addr
+        return self.addr
+
+    def poll(self, event, timeout):
+        if event == "recv":
+            with self.recv_ready:
+                if len(self.recv_queue) == 0:
+                    self.recv_ready.wait(timeout)
+                if len(self.recv_queue) > 0:
+                    return self.recv_queue[0]
+                return None
+        if event == "send":
+            with self.send_ready:
+                if len(self.send_queue) >= self.send_buf:
+                    self.send_ready.wait(timeout)
+                return len(self.send_queue) < self.send_buf
+
+    def send(self, send_pdu, flags):
+        with self.send_ready:
+            self.send_queue.append(send_pdu)
+            if not (flags & nfc.llcp.MSG_DONTWAIT):
+                self.send_ready.wait()
+
+    def recv(self):
+        with self.recv_ready:
+            try:
+                return self.recv_queue.popleft()
+            except IndexError:
+                self.recv_ready.wait()
+            return self.recv_queue.popleft()
+
+    def close(self):
+        with self.lock:
+            self.send_queue.clear()
+            self.recv_queue.clear()
+            self.send_ready.notify_all()
+            self.recv_ready.notify_all()
+            self.state.SHUTDOWN = True
+
+    #
+    # enqueue() and dequeue() are called from llc run thread
+    #
+    def enqueue(self, rcvd_pdu):
+        with self.lock:
+            if len(self.recv_queue) < self.recv_buf:
+                log.debug("enqueue {0}".format(rcvd_pdu))
+                self.recv_queue.append(rcvd_pdu)
+                self.recv_ready.notify()
+                return True
+            else:
+                log.warning("discard {0}".format(rcvd_pdu))
+                return False
+
+    def dequeue(self, miu_size, icv_size, notify=True):
+        # Return the first pending outbound PDU if it's information
+        # field size (total size - header size) does not exceed the
+        # given miu_size value. For UI and I PDUs do also consider the
+        # icv_size value (this is set to non-zero by the packet
+        # collector when aggregating). Re-insert the PDU at the
+        # beginning of the send queue if it exceeds the miu_size.
+        # Skip the length check if miu_size is None.
+        with self.lock:
+            try:
+                send_pdu = self.send_queue.popleft()
+                log.debug("dequeue {0}".format(send_pdu))
+            except IndexError:
+                return None
+
+            if send_pdu.name in ("UI", "I"):
+                pdu_size = len(send_pdu) + icv_size
+            else:
+                pdu_size = len(send_pdu)
+
+            if ((miu_size is not None and
+                 pdu_size - send_pdu.header_size > miu_size)):
+                log.debug("requeue {0}".format(send_pdu))
+                self.send_queue.appendleft(send_pdu)
+                return None
+
+            if notify is True:
+                self.send_ready.notify()
+
+            return send_pdu
+
+
+class RawAccessPoint(TransmissionControlObject):
+    """
+    ============= =========== ============
+        State        Event     Transition
+    ============= =========== ============
+    SHUTDOWN      init()      ESTABLISHED
+    ESTABLISHED   close()     SHUTDOWN
+    ============= =========== ============
+    """
+    def __init__(self, recv_miu):
+        super(RawAccessPoint, self).__init__(128, recv_miu)
+        self.state.ESTABLISHED = True
+
+    def __str__(self):
+        return "RAW {:2} ->  ?".format(self.addr
+                                       if self.addr is not None
+                                       else "None")
+
+    def setsockopt(self, option, value):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        super(RawAccessPoint, self).setsockopt(option, value)
+
+    def getsockopt(self, option):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        return super(RawAccessPoint, self).getsockopt(option)
+
+    def poll(self, event, timeout):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        if event not in ("recv", "send"):
+            raise err.Error(errno.EINVAL)
+        return super(RawAccessPoint, self).poll(event, timeout) is not None
+
+    def send(self, send_pdu, flags):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        log.debug("{0} send {1}".format(str(self), send_pdu))
+        super(RawAccessPoint, self).send(send_pdu, flags)
+        return self.state.ESTABLISHED is True
+
+    def recv(self):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        try:
+            return super(RawAccessPoint, self).recv()
+        except IndexError:
+            raise err.Error(errno.EPIPE)
+
+    def close(self):
+        super(RawAccessPoint, self).close()
+
+    #
+    # enqueue() and dequeue() are called from llc run thread
+    #
+    def enqueue(self, rcvd_pdu):
+        return super(RawAccessPoint, self).enqueue(rcvd_pdu)
+
+    def dequeue(self, miu_size, icv_size):
+        return super(RawAccessPoint, self).dequeue(miu_size=None, icv_size=0)
+
+
+class LogicalDataLink(TransmissionControlObject):
+    """
+    ============= =========== ============
+        State        Event     Transition
+    ============= =========== ============
+    SHUTDOWN      init()      ESTABLISHED
+    ESTABLISHED   close()     SHUTDOWN
+    ============= =========== ============
+    """
+    def __init__(self, recv_miu):
+        super(LogicalDataLink, self).__init__(128, recv_miu)
+        self.state.ESTABLISHED = True
+
+    def __str__(self):
+        return "LDL {addr:2} -> {peer:2}".format(
+                addr=self.addr if self.addr is not None else "None",
+                peer=self.peer if self.peer is not None else "None"
+        )
+
+    def setsockopt(self, option, value):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        super(LogicalDataLink, self).setsockopt(option, value)
+
+    def getsockopt(self, option):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        return super(LogicalDataLink, self).getsockopt(option)
+
+    def connect(self, dest):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        with self.lock:
+            self.peer = dest
+            return self.peer > 0
+
+    def poll(self, event, timeout):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        if event not in ("recv", "send"):
+            raise err.Error(errno.EINVAL)
+        return super(LogicalDataLink, self).poll(event, timeout) is not None
+
+    def sendto(self, message, dest, flags):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        if self.peer and dest != self.peer:
+            raise err.Error(errno.EDESTADDRREQ)
+        if len(message) > self.send_miu:
+            raise err.Error(errno.EMSGSIZE)
+        send_pdu = pdu.UnnumberedInformation(dest, self.addr, data=message)
+        super(LogicalDataLink, self).send(send_pdu, flags)
+        return self.state.ESTABLISHED is True
+
+    def recvfrom(self):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+        try:
+            rcvd_pdu = super(LogicalDataLink, self).recv()
+        except IndexError:
+            raise err.Error(errno.EPIPE)
+        return (rcvd_pdu.data, rcvd_pdu.ssap) if rcvd_pdu else (None, None)
+
+    def close(self):
+        super(LogicalDataLink, self).close()
+
+    #
+    # enqueue() and dequeue() are called from llc run thread
+    #
+    def enqueue(self, rcvd_pdu):
+        if not rcvd_pdu.name == "UI":
+            log.warning("ignore %s PDU on logical data link", rcvd_pdu.name)
+            return False
+        if len(rcvd_pdu.data) > self.recv_miu:
+            log.warning("received UI PDU exceeds local link MIU")
+            return False
+        return super(LogicalDataLink, self).enqueue(rcvd_pdu)
+
+    def dequeue(self, miu_size, icv_size):
+        return super(LogicalDataLink, self).dequeue(miu_size, icv_size)
+
+
+class DataLinkConnection(TransmissionControlObject):
+    """
+    ============= =========== ============
+        State        Event     Transition
+    ============= =========== ============
+    SHUTDOWN      init()      ESTABLISHED
+    CLOSED        listen()    LISTEN
+    CLOSED        connect()   CONNECT
+    CONNECT       CC-PDU      ESTABLISHED
+    CONNECT       DM-PDU      CLOSED
+    ESTABLISHED   I-PDU       ESTABLISHED
+    ESTABLISHED   RR-PDU      ESTABLISHED
+    ESTABLISHED   RNR-PDU     ESTABLISHED
+    ESTABLISHED   FRMR-PDU    SHUTDOWN
+    ESTABLISHED   DISC-PDU    CLOSE_WAIT
+    ESTABLISHED   close()     SHUTDOWN
+    CLOSE_WAIT    close()     SHUTDOWN
+    ============= =========== ============
+    """
+
+    DLC_PDU_NAMES = ("CONNECT", "DISC", "CC", "DM", "FRMR", "I", "RR", "RNR")
+
+    def __init__(self, recv_miu, recv_win):
+        super(DataLinkConnection, self).__init__(128, recv_miu)
+        self.state.CLOSED = True
+        self.acks_ready = threading.Condition(self.lock)
+        self.acks_recvd = 0  # received acknowledgements
+        self.recv_confs = 0  # outstanding receive confirmations
+        self.send_token = threading.Condition(self.lock)
+        self.recv_buf = recv_win
+        self.recv_win = recv_win  # RW(Local)
+        self.recv_cnt = 0         # V(R)
+        self.recv_ack = 0         # V(RA)
+        self.send_win = None      # RW(Remote)
+        self.send_cnt = 0         # V(S)
+        self.send_ack = 0         # V(SA)
+
+    def __str__(self):
+        s = "DLC {addr:2} <-> {peer:2} {dlc.state} "
+        s += "RW(R)={dlc.send_win} V(S)={dlc.send_cnt} V(SA)={dlc.send_ack} "
+        s += "RW(L)={dlc.recv_win} V(R)={dlc.recv_cnt} V(RA)={dlc.recv_ack}"
+        return s.format(
+                dlc=self,
+                addr=self.addr if self.addr is not None else "None",
+                peer=self.peer if self.peer is not None else "None"
+        )
+
+    def log(self, string):
+        log.debug("DLC ({dlc.addr},{dlc.peer}) {dlc.state} {s}"
+                  .format(dlc=self, s=string))
+
+    def err(self, string):
+        log.error("DLC ({dlc.addr},{dlc.peer}) {s}".format(dlc=self, s=string))
+
+    def setsockopt(self, option, value):
+        with self.lock:
+            if option == nfc.llcp.SO_RCVMIU and self.state.CLOSED:
+                self.recv_miu = min(value, 2175)
+                return
+            if option == nfc.llcp.SO_RCVBUF and self.state.CLOSED:
+                self.recv_win = min(value, 15)
+                self.recv_buf = self.recv_win
+                return
+            if option == nfc.llcp.SO_RCVBSY:
+                self.mode.RECV_BUSY = bool(value)
+                return
+            super(DataLinkConnection, self).setsockopt(option, value)
+
+    def getsockopt(self, option):
+        if option == nfc.llcp.SO_RCVBUF:
+            return self.recv_win
+        if option == nfc.llcp.SO_SNDBSY:
+            return self.mode.SEND_BUSY
+        if option == nfc.llcp.SO_RCVBSY:
+            return self.mode.RECV_BUSY
+        return super(DataLinkConnection, self).getsockopt(option)
+
+    def listen(self, backlog):
+        with self.lock:
+            if self.state.SHUTDOWN:
+                raise err.Error(errno.ESHUTDOWN)
+            if not self.state.CLOSED:
+                self.err("listen() but socket state is {0}".format(self.state))
+                raise err.Error(errno.ENOTSUP)
+            self.state.LISTEN = True
+            self.recv_buf = backlog
+
+    def accept(self):
+        with self.lock:
+            if self.state.SHUTDOWN:
+                raise err.Error(errno.ESHUTDOWN)
+            if not self.state.LISTEN:
+                self.err("accept() but socket state is {0}".format(self.state))
+                raise err.Error(errno.EINVAL)
+            self.recv_buf += 1
+            try:
+                rcvd_pdu = super(DataLinkConnection, self).recv()
+            except IndexError:
+                raise err.Error(errno.EPIPE)
+            self.recv_buf -= 1
+            if rcvd_pdu.name == "CONNECT":
+                dlc = DataLinkConnection(self.recv_miu, self.recv_win)
+                dlc.addr = self.addr
+                dlc.peer = rcvd_pdu.ssap
+                dlc.send_miu = rcvd_pdu.miu
+                dlc.send_win = rcvd_pdu.rw
+                send_pdu = pdu.ConnectionComplete(dlc.peer, dlc.addr)
+                send_pdu.miu, send_pdu.rw = dlc.recv_miu, dlc.recv_win
+                log.debug("accepting CONNECT from SAP %d" % dlc.peer)
+                dlc.state.ESTABLISHED = True
+                self.send_queue.append(send_pdu)
+                return dlc
+            else:  # pragma: no cover
+                raise RuntimeError("CONNECT expected, not " + rcvd_pdu.name)
+
+    def connect(self, dest):
+        with self.lock:
+            if not self.state.CLOSED:
+                self.err("connect() in socket state {0}".format(self.state))
+                if self.state.ESTABLISHED:
+                    raise err.Error(errno.EISCONN)
+                if self.state.CONNECT:
+                    raise err.Error(errno.EALREADY)
+                raise err.Error(errno.EPIPE)
+            if isinstance(dest, (bytes, bytearray)):
+                send_pdu = pdu.Connect(1, self.addr, self.recv_miu,
+                                       self.recv_win, bytes(dest))
+            elif isinstance(dest, str):
+                send_pdu = pdu.Connect(1, self.addr, self.recv_miu,
+                                       self.recv_win, dest.encode('latin'))
+            elif isinstance(dest, int):
+                send_pdu = pdu.Connect(dest, self.addr, self.recv_miu,
+                                       self.recv_win)
+            else:
+                raise TypeError("connect destination must be int or bytes")
+
+            self.state.CONNECT = True
+            self.send_queue.append(send_pdu)
+
+            try:
+                rcvd_pdu = super(DataLinkConnection, self).recv()
+            except IndexError:
+                raise err.Error(errno.EPIPE)
+
+            if rcvd_pdu.name == "DM":
+                logstr = "connect rejected with reason {}"
+                self.log(logstr.format(rcvd_pdu.reason))
+                self.state.CLOSED = True
+                raise err.ConnectRefused(rcvd_pdu.reason)
+            elif rcvd_pdu.name == "CC":
+                self.peer = rcvd_pdu.ssap
+                self.recv_buf = self.recv_win
+                self.send_miu = rcvd_pdu.miu
+                self.send_win = rcvd_pdu.rw
+                self.state.ESTABLISHED = True
+                return
+            else:  # pragma: no cover
+                raise RuntimeError("CC or DM expected, not " + rcvd_pdu.name)
+
+    @property
+    def send_window_slots(self):
+        # RW(R) - V(S) + V(SA) mod 16
+        return (self.send_win - self.send_cnt + self.send_ack) % 16
+
+    @property
+    def recv_window_slots(self):
+        # RW(L) - V(R) + V(RA) mod 16
+        return (self.recv_win - self.recv_cnt + self.recv_ack) % 16
+
+    def send(self, message, flags):
+        with self.send_token:
+            if not self.state.ESTABLISHED:
+                self.err("send() in socket state {0}".format(self.state))
+                if self.state.CLOSE_WAIT:
+                    raise err.Error(errno.EPIPE)
+                raise err.Error(errno.ENOTCONN)
+            if len(message) > self.send_miu:
+                raise err.Error(errno.EMSGSIZE)
+            while self.send_window_slots == 0 and self.state.ESTABLISHED:
+                if flags & nfc.llcp.MSG_DONTWAIT:
+                    raise err.Error(errno.EWOULDBLOCK)
+                self.log("waiting on busy send window")
+                self.send_token.wait()
+            self.log("send {0} byte on {1}".format(len(message), str(self)))
+            if self.state.ESTABLISHED:
+                send_pdu = pdu.Information(self.peer, self.addr, data=message)
+                send_pdu.ns = self.send_cnt
+                self.send_cnt = (self.send_cnt + 1) % 16
+                super(DataLinkConnection, self).send(send_pdu, flags)
+            return self.state.ESTABLISHED is True
+
+    def recv(self):
+        with self.lock:
+            if not (self.state.ESTABLISHED or self.state.CLOSE_WAIT):
+                self.err("recv() in socket state {0}".format(self.state))
+                raise err.Error(errno.ENOTCONN)
+
+            try:
+                rcvd_pdu = super(DataLinkConnection, self).recv()
+            except IndexError:
+                return None
+
+            if rcvd_pdu.name == "I":
+                self.recv_confs += 1
+                if self.recv_confs > self.recv_win:
+                    self.err("recv_confs({0}) > recv_win({1})"
+                             .format(self.recv_confs, self.recv_win))
+                    raise RuntimeError("recv_confs > recv_win")
+                return rcvd_pdu.data
+
+            if rcvd_pdu.name == "DISC":
+                self.close()
+                return None
+
+            raise RuntimeError("only I or DISC expected, not " + rcvd_pdu.name)
+
+    def poll(self, event, timeout):
+        if self.state.SHUTDOWN:
+            raise err.Error(errno.ESHUTDOWN)
+
+        if event == "recv":
+            if self.state.ESTABLISHED or self.state.CLOSE_WAIT:
+                rcvd_pdu = super(DataLinkConnection, self).poll(event, timeout)
+                if self.state.ESTABLISHED or self.state.CLOSE_WAIT:
+                    return isinstance(rcvd_pdu, pdu.Information)
+        elif event == "send":
+            if self.state.ESTABLISHED:
+                if super(DataLinkConnection, self).poll(event, timeout):
+                    return self.state.ESTABLISHED
+                return False
+        elif event == "acks":
+            with self.acks_ready:
+                if not self.acks_recvd > 0:
+                    self.acks_ready.wait(timeout)
+                if self.acks_recvd > 0:
+                    self.acks_recvd = self.acks_recvd - 1
+                    return True
+                return False
+        else:
+            raise err.Error(errno.EINVAL)
+
+    def close(self):
+        with self.lock:
+            self.log("close()")
+            if self.state.ESTABLISHED and self.is_bound:
+                self.state.DISCONNECT = True
+                self.send_token.notify_all()
+                self.acks_ready.notify_all()
+                send_pdu = pdu.Disconnect(self.peer, self.addr)
+                self.send_queue.append(send_pdu)
+                try:
+                    super(DataLinkConnection, self).recv()
+                except IndexError:
+                    pass
+            super(DataLinkConnection, self).close()
+            self.acks_ready.notify_all()
+            self.send_token.notify_all()
+
+    #
+    # enqueue() and dequeue() are called from llc thread context
+    #
+    def enqueue(self, rcvd_pdu):
+        self.log("enqueue {pdu.name} PDU".format(pdu=rcvd_pdu))
+
+        if rcvd_pdu.name not in self.DLC_PDU_NAMES:
+            self.err("non connection mode pdu on data link connection")
+            send_pdu = pdu.FrameReject.from_pdu(rcvd_pdu, flags="W", dlc=self)
+            self.close()
+            self.send_queue.append(send_pdu)
+            return
+
+        if self.state.CLOSED:
+            self.send_queue.append(pdu.DisconnectedMode(
+                rcvd_pdu.ssap, rcvd_pdu.dsap, reason=1))
+
+        elif self.state.LISTEN and rcvd_pdu.name == "CONNECT":
+            if super(DataLinkConnection, self).enqueue(rcvd_pdu) is False:
+                log.warning("full backlog on listening socket")
+                self.send_queue.append(pdu.DisconnectedMode(
+                    rcvd_pdu.ssap, rcvd_pdu.dsap, reason=0x20))
+
+        elif self.state.CONNECT and rcvd_pdu.name in ("CC", "DM"):
+            with self.lock:
+                self.recv_queue.append(rcvd_pdu)
+                self.recv_ready.notify()
+
+        elif self.state.DISCONNECT and rcvd_pdu.name == "DM":
+            with self.lock:
+                self.recv_queue.append(rcvd_pdu)
+                self.recv_ready.notify()
+
+        elif self.state.ESTABLISHED:
+            return self._enqueue_state_established(rcvd_pdu)
+
+    def _enqueue_state_established(self, rcvd_pdu):
+        if rcvd_pdu.name == "I":
+            frmr = None
+            if len(rcvd_pdu.data) > self.recv_miu:
+                frmr = pdu.FrameReject.from_pdu(rcvd_pdu, flags="I", dlc=self)
+            elif rcvd_pdu.ns != self.recv_cnt:
+                frmr = pdu.FrameReject.from_pdu(rcvd_pdu, flags="S", dlc=self)
+            if frmr:
+                self.log("reject " + str(self))
+                self.send_queue.clear()
+                self.send_queue.append(frmr)
+                log.debug("enqueued frame reject pdu")
+                return
+
+        if rcvd_pdu.name == "FRMR":
+            with self.lock:
+                self.state.SHUTDOWN = True
+                self.close()
+            return
+
+        if rcvd_pdu.name == "DISC":
+            with self.lock:
+                self.state.CLOSE_WAIT = True
+                self.send_queue.clear()
+                self.send_queue.append(pdu.DisconnectedMode(
+                    self.peer, self.addr, reason=0))
+            return
+
+        if rcvd_pdu.name in ("I", "RR", "RNR"):
+            with self.lock:
+                # acks = N(R) - V(SA) mod 16
+                acks = (rcvd_pdu.nr - self.send_ack) % 16
+                if acks:
+                    self.acks_recvd += acks
+                    self.acks_ready.notify_all()
+                    self.send_token.notify()
+                    self.send_ack = rcvd_pdu.nr  # V(SA) := N(R)
+                if rcvd_pdu.name == "RNR":
+                    self.mode.SEND_BUSY = True
+                if rcvd_pdu.name == "RR":
+                    self.mode.SEND_BUSY = False
+
+        if rcvd_pdu.name == "I":
+            with self.lock:
+                # V(R) := V(R) + 1 mod 16
+                self.recv_cnt = (self.recv_cnt + 1) % 16
+            super(DataLinkConnection, self).enqueue(rcvd_pdu)
+
+    def dequeue(self, miu_size, icv_size):
+        with self.lock:
+            if self.state.ESTABLISHED:
+                if self.mode.RECV_BUSY_SENT != self.mode.RECV_BUSY:
+                    self.mode.RECV_BUSY_SENT = self.mode.RECV_BUSY
+                    ACK = RNR_PDU if self.mode.RECV_BUSY else RR_PDU
+                    return ACK(self.peer, self.addr, self.recv_ack)
+
+            send_pdu = super(DataLinkConnection, self).dequeue(
+                miu_size, icv_size, notify=False)
+
+            if send_pdu:
+                self.log("dequeue {0} PDU".format(send_pdu.name))
+
+                if send_pdu.name == "FRMR":
+                    self.state.SHUTDOWN = True
+                    self.close()
+
+                if send_pdu.name == "I" and self.state.ESTABLISHED:
+                    if self.recv_confs and self.recv_cnt != self.recv_ack:
+                        self.log("piggyback ack " + str(self))
+                        self.recv_ack = (self.recv_ack + self.recv_confs) % 16
+                        self.recv_confs = 0
+                    send_pdu.nr = self.recv_ack
+                    self.send_ready.notify()
+
+                if send_pdu.name == "DM" and self.state.CLOSE_WAIT:
+                    self.recv_queue.append(pdu.Disconnect(
+                        dsap=self.peer, ssap=self.addr))
+                    self.recv_ready.notify()
+                    self.send_token.notify_all()
+
+            else:
+                if ((self.state.ESTABLISHED and self.recv_confs
+                     and self.recv_window_slots == 0)):
+                    # must send acknowledgement to keep going
+                    self.log("necessary ack " + str(self))
+                    self.recv_ack = (self.recv_ack + self.recv_confs) % 16
+                    self.recv_confs = 0
+                    ACK = RNR_PDU if self.mode.RECV_BUSY else RR_PDU
+                    return ACK(self.peer, self.addr, self.recv_ack)
+
+            return send_pdu
+
+    def sendack(self):
+        if self.state.ESTABLISHED:
+            with self.lock:
+                if self.recv_confs and self.recv_cnt != self.recv_ack:
+                    self.log("voluntary ack " + str(self))
+                    self.recv_ack = (self.recv_ack + self.recv_confs) % 16
+                    self.recv_confs = 0
+                    ACK = RNR_PDU if self.mode.RECV_BUSY else RR_PDU
+                    return ACK(self.peer, self.addr, self.recv_ack)
+
+
+RR_PDU, RNR_PDU = pdu.ReceiveReady, pdu.ReceiveNotReady

src/lib/nfc/snep/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+"""
+The nfc.snep module implements the NFC Forum Simple NDEF Exchange
+Protocol (SNEP) specification and provides a server and client class
+for applications to easily send or receive SNEP messages.
+"""
+from src.lib.nfc.snep.server import SnepServer                             # noqa: F401
+from src.lib.nfc.snep.client import SnepClient                             # noqa: F401
+from src.lib.nfc.snep.client import SnepError                              # noqa: F401
+
+Success = 0x81
+NotFound = 0xC0
+ExcessData = 0xC1
+BadRequest = 0xC2
+NotImplemented = 0xE0
+UnsupportedVersion = 0xE1

src/lib/nfc/snep/client.py

@@ -0,0 +1,247 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+#
+# Simple NDEF Exchange Protocol (SNEP) - Client Base Class
+#
+import ndef
+import struct
+import src.lib.nfc.llcp
+
+import logging
+log = logging.getLogger(__name__)
+
+
+def send_request(socket, snep_request, send_miu):
+    if len(snep_request) <= send_miu:
+        return socket.send(snep_request)
+
+    if not socket.send(snep_request[0:send_miu]):
+        return False
+
+    if socket.recv() != b"\x10\x80\x00\x00\x00\x00":
+        return False
+
+    for offset in range(send_miu, len(snep_request), send_miu):
+        fragment = snep_request[offset:offset+send_miu]
+        if not socket.send(fragment):
+            return False
+
+    return True
+
+
+def recv_response(socket, acceptable_length, timeout):
+    if socket.poll("recv", timeout):
+        snep_response = socket.recv()
+
+        if len(snep_response) < 6:
+            log.debug("snep response initial fragment too short")
+            return None
+
+        version, status, length = struct.unpack(">BBL", snep_response[:6])
+
+        if length > acceptable_length:
+            log.debug("snep response exceeds acceptable length")
+            return None
+
+        if len(snep_response) - 6 < length:
+            # request remaining fragments
+            socket.send(b"\x10\x00\x00\x00\x00\x00")
+            while len(snep_response) - 6 < length:
+                if socket.poll("recv", timeout):
+                    snep_response += socket.recv()
+                else:
+                    return None
+
+        return bytearray(snep_response)
+
+
+class SnepClient(object):
+    """ Simple NDEF exchange protocol - client implementation
+    """
+    def __init__(self, llc, max_ndef_msg_recv_size=1024):
+        self.acceptable_length = max_ndef_msg_recv_size
+        self.socket = None
+        self.llc = llc
+
+    def connect(self, service_name):
+        """Connect to a SNEP server. This needs only be called to
+        connect to a server other than the Default SNEP Server at
+        `urn:nfc:sn:snep` or if the client wants to send multiple
+        requests with a single connection.
+        """
+        self.close()
+        self.socket = nfc.llcp.Socket(self.llc, nfc.llcp.DATA_LINK_CONNECTION)
+        self.socket.connect(service_name)
+        self.send_miu = self.socket.getsockopt(nfc.llcp.SO_SNDMIU)
+
+    def close(self):
+        """Close the data link connection with the SNEP server.
+        """
+        if self.socket:
+            self.socket.close()
+            self.socket = None
+
+    def get_records(self, records=None, timeout=1.0):
+        """Get NDEF message records from a SNEP Server.
+
+        .. versionadded:: 0.13
+
+        The :class:`ndef.Record` list given by *records* is encoded as
+        the request message octets input to :meth:`get_octets`. The
+        return value is an :class:`ndef.Record` list decoded from the
+        response message octets returned by :meth:`get_octets`. Same
+        as::
+
+            import ndef
+            send_octets = ndef.message_encoder(records)
+            rcvd_octets = snep_client.get_octets(send_octets, timeout)
+            records = list(ndef.message_decoder(rcvd_octets))
+
+        """
+        octets = b''.join(ndef.message_encoder(records)) if records else None
+        octets = self.get_octets(octets, timeout)
+        if octets and len(octets) >= 3:
+            return list(ndef.message_decoder(octets))
+
+    def get_octets(self, octets=None, timeout=1.0):
+        """Get NDEF message octets from a SNEP Server.
+
+        .. versionadded:: 0.13
+
+        If the client has not yet a data link connection with a SNEP
+        Server, it temporarily connects to the default SNEP Server,
+        sends the message octets, disconnects after the server
+        response, and returns the received message octets.
+
+        """
+        if octets is None:
+            # Send NDEF Message with one empty Record.
+            octets = b'\xd0\x00\x00'
+
+        if not self.socket:
+            try:
+                self.connect('urn:nfc:sn:snep')
+            except nfc.llcp.ConnectRefused:
+                return None
+            else:
+                self.release_connection = True
+        else:
+            self.release_connection = False
+
+        try:
+            request = struct.pack('>BBLL', 0x10, 0x01, 4 + len(octets),
+                                  self.acceptable_length) + octets
+
+            if not send_request(self.socket, request, self.send_miu):
+                return None
+
+            response = recv_response(
+                self.socket, self.acceptable_length, timeout)
+
+            if response is not None:
+                if response[1] != 0x81:
+                    raise SnepError(response[1])
+
+                return response[6:]
+
+        finally:
+            if self.release_connection:
+                self.close()
+
+    def put_records(self, records, timeout=1.0):
+        """Send NDEF message records to a SNEP Server.
+
+        .. versionadded:: 0.13
+
+        The :class:`ndef.Record` list given by *records* is encoded
+        and then send via :meth:`put_octets`. Same as::
+
+            import ndef
+            octets = ndef.message_encoder(records)
+            snep_client.put_octets(octets, timeout)
+
+        """
+        octets = b''.join(ndef.message_encoder(records))
+        return self.put_octets(octets, timeout)
+
+    def put_octets(self, octets, timeout=1.0):
+        """Send NDEF message octets to a SNEP Server.
+
+        .. versionadded:: 0.13
+
+        If the client has not yet a data link connection with a SNEP
+        Server, it temporarily connects to the default SNEP Server,
+        sends the message octets and disconnects after the server
+        response.
+
+        """
+        if not self.socket:
+            try:
+                self.connect('urn:nfc:sn:snep')
+            except nfc.llcp.ConnectRefused:
+                return False
+            else:
+                self.release_connection = True
+        else:
+            self.release_connection = False
+
+        try:
+            request = struct.pack('>BBL', 0x10, 0x02, len(octets)) + octets
+            if not send_request(self.socket, request, self.send_miu):
+                return False
+
+            response = recv_response(self.socket, 0, timeout)
+            if response is not None:
+                if response[1] != 0x81:
+                    raise SnepError(response[1])
+
+            return True
+
+        finally:
+            if self.release_connection:
+                self.close()
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
+class SnepError(Exception):
+    strerr = {0xC0: "resource not found",
+              0xC1: "resource exceeds data size limit",
+              0xC2: "malformed request not understood",
+              0xE0: "unsupported functionality requested",
+              0xE1: "unsupported protocol version"}
+
+    def __init__(self, err):
+        self.args = (err, SnepError.strerr.get(err, ""))
+
+    def __str__(self):
+        return "nfc.snep.SnepError: [{errno}] {info}".format(
+            errno=self.args[0], info=self.args[1])
+
+    @property
+    def errno(self):
+        return self.args[0]

src/lib/nfc/snep/server.py

@@ -0,0 +1,175 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+#
+# Simple NDEF Exchange Protocol (SNEP) - Server Base Class
+#
+import threading
+import binascii
+import logging
+import struct
+import errno
+import ndef
+import src.lib.nfc
+
+
+log = logging.getLogger(__name__)
+
+
+class SnepServer(threading.Thread):
+    """ NFC Forum Simple NDEF Exchange Protocol server
+    """
+    def __init__(self, llc, service_name="urn:nfc:sn:snep",
+                 max_acceptable_length=0x100000,
+                 recv_miu=1984, recv_buf=15):
+
+        self.max_acceptable_length = min(max_acceptable_length, 0xFFFFFFFF)
+        socket = nfc.llcp.Socket(llc, nfc.llcp.DATA_LINK_CONNECTION)
+        recv_miu = socket.setsockopt(nfc.llcp.SO_RCVMIU, recv_miu)
+        recv_buf = socket.setsockopt(nfc.llcp.SO_RCVBUF, recv_buf)
+        socket.bind(service_name)
+        log.info("snep server bound to port {0} (MIU={1}, RW={2}), "
+                 "will accept up to {3} byte NDEF messages"
+                 .format(socket.getsockname(), recv_miu, recv_buf,
+                         self.max_acceptable_length))
+        socket.listen(backlog=2)
+        threading.Thread.__init__(self, name=service_name,
+                                  target=self._listen, args=(socket,))
+
+    def _listen(self, listen_socket):
+        try:
+            while True:
+                client_socket = listen_socket.accept()
+                client_thread = threading.Thread(target=self._serve,
+                                                 args=(client_socket,))
+                client_thread.start()
+        except nfc.llcp.Error as error:
+            (log.debug if error.errno == errno.EPIPE else log.error)(error)
+        finally:
+            listen_socket.close()
+
+    def _serve(self, client_socket):
+        peer_sap = client_socket.getpeername()
+        log.info("serving snep client on remote sap {0}".format(peer_sap))
+        send_miu = client_socket.getsockopt(nfc.llcp.SO_SNDMIU)
+        try:
+            while client_socket.poll('recv'):
+                data = bytearray(client_socket.recv())
+                if not data:
+                    break  # connection closed
+
+                if len(data) < 6:
+                    log.debug("snep msg initial fragment too short")
+                    break  # bail out, this is a bad client
+
+                version, length = struct.unpack_from(">BxL", data)
+
+                if (version >> 4) > 1:
+                    log.debug("unsupported version {0}".format(version >> 4))
+                    client_socket.send(b"\x10\xE1\x00\x00\x00\x00")
+                    continue
+
+                if length > self.max_acceptable_length:
+                    log.debug("snep msg exceeds max acceptable length")
+                    client_socket.send(b"\x10\xFF\x00\x00\x00\x00")
+                    continue
+
+                if len(data) - 6 < length:
+                    # request remaining fragments
+                    client_socket.send(b"\x10\x80\x00\x00\x00\x00")
+                    while len(data) - 6 < length:
+                        try:
+                            data += client_socket.recv()
+                        except TypeError:
+                            break  # connection closed
+
+                # message complete, now handle the request
+                data = self.process_snep_request(data)
+
+                # send the snep response, fragment if needed
+                if len(data) <= send_miu:
+                    client_socket.send(data)
+                else:
+                    client_socket.send(data[0:send_miu])
+                    if client_socket.recv() == b"\x10\x00\x00\x00\x00\x00":
+                        parts = range(send_miu, len(data), send_miu)
+                        for offset in parts:
+                            client_socket.send(data[offset:offset + send_miu])
+
+        except nfc.llcp.Error as e:
+            (log.debug if e.errno == nfc.llcp.errno.EPIPE else log.error)(e)
+        finally:
+            client_socket.close()
+
+    def process_snep_request(self, request_data):
+        assert isinstance(request_data, bytearray)
+        log.debug("<<< %s", binascii.hexlify(request_data).decode())
+        try:
+            if request_data[1] == 1 and len(request_data) >= 10:
+                acceptable_length = struct.unpack(">L", request_data[6:10])[0]
+                octets = request_data[10:]
+                records = list(ndef.message_decoder(octets, known_types={}))
+                response = self.process_get_request(records)
+                if isinstance(response, int):
+                    response_code = response
+                    response_data = b''
+                else:
+                    response_code = 0x81  # nfc.snep.Success
+                    response_data = b''.join(ndef.message_encoder(response))
+                if len(response_data) > acceptable_length:
+                    response_code = 0xC1  # nfc.snep.ExcessData
+                    response_data = b''
+            elif request_data[1] == 2:
+                octets = request_data[6:]
+                records = list(ndef.message_decoder(octets, known_types={}))
+                response_code = self.process_put_request(records)
+                response_data = b''
+            else:
+                log.debug("bad request (0x{:02x})".format(request_data[1]))
+                response_code = 0xC2  # nfc.snep.BadRequest
+                response_data = b''
+        except ndef.DecodeError as error:
+            log.error(repr(error))
+            response_code = 0xC2  # nfc.snep.BadRequest
+            response_data = b''
+        except ndef.EncodeError as error:
+            log.error(repr(error))
+            response_code = 0xC0  # nfc.snep.NotFound
+            response_data = b''
+
+        header = struct.pack(">BBL", 0x10, response_code, len(response_data))
+        response_data = header + response_data
+        log.debug(">>> %s", binascii.hexlify(response_data).decode())
+        return response_data
+
+    def process_get_request(self, ndef_message):
+        """Handle Get requests. This method should be overwritten by a
+        subclass of SnepServer to customize it's behavior. The default
+        implementation simply returns nfc.snep.NotImplemented.
+        """
+        return 0xE0  # NotImplemented
+
+    def process_put_request(self, ndef_message):
+        """Process a SNEP Put request. This method should be overwritten by a
+        subclass of SnepServer to customize it's behavior. The default
+        implementation simply returns nfc.snep.Success.
+        """
+        return 0x81  # nfc.snep.Success

src/lib/nfc/tag/__init__.py

@@ -0,0 +1,480 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2013, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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
+from binascii import hexlify
+from ndef import message_decoder, message_encoder
+
+
+logging.captureWarnings(True)
+log = logging.getLogger(__name__)
+
+
+class Tag(object):
+    """The base class for all NFC Tags/Cards. The methods and attributes
+    defined here are commonly available but some may, depending on the
+    tag product, also return a :const:`None` value is support is not
+    available.
+
+    Direct subclasses are the NFC Forum tag types:
+    :class:`~nfc.tag.tt1.Type1Tag`, :class:`~nfc.tag.tt2.Type2Tag`,
+    :class:`~nfc.tag.tt3.Type3Tag`, :class:`~nfc.tag.tt4.Type4Tag`.
+    Some of them are further specialized in vendor/product specific
+    classes.
+
+    """
+    class NDEF(object):
+        """The NDEF object type that may be read from :attr:`Tag.ndef`.
+
+        This class presents the NDEF management information and the
+        actual NDEF message by a couple of attributes. It is normally
+        accessed from a :class:`Tag` instance (further named *tag*)
+        through the :attr:`Tag.ndef` attribute for reading or writing
+        NDEF records. ::
+
+            if tag.ndef is not None:
+                for record in tag.ndef.records:
+                    print(record)
+                if tag.ndef.is_writeable:
+                    from ndef import TextRecord
+                    tag.ndef.records = [TextRecord("Hello World")]
+
+        """
+        def __init__(self, tag):
+            self._tag = tag
+            self._data = None
+            self._capacity = 0
+            self._readable = False
+            self._writeable = False
+
+        def _read_ndef_data(self):
+            msg = "_read_ndef_data is not implemented for this tag type"
+            raise NotImplementedError(msg)
+
+        def _write_ndef_data(self, data):
+            msg = "_write_ndef_data is not implemented for this tag type"
+            raise NotImplementedError(msg)
+
+        @property
+        def tag(self):
+            """A readonly reference to the underlying tag object."""
+            return self._tag
+
+        @property
+        def length(self):
+            """Length of the current NDEF message in bytes."""
+            return len(self._data) if self._data else 0
+
+        @property
+        def capacity(self):
+            """Maximum number of bytes for an NDEF message."""
+            return self._capacity
+
+        @property
+        def is_readable(self):
+            """:const:`True` if the NDEF data are is readable."""
+            return self._readable
+
+        @property
+        def is_writeable(self):
+            """:const:`True` if the NDEF data area is writeable."""
+            return self._writeable
+
+        @property
+        def has_changed(self):
+            """The boolean attribute :attr:`has_changed` allows to determine
+            whether the NDEF message on the tag is different from the
+            message that was read or written at an earlier time in the
+            session. This may for example be the case if the tag is
+            build to dynamically present different content depending
+            on some state.
+
+            Note that reading this attribute involves a complete
+            update of the :class:`Tag.NDEF` instance and it is
+            possible that :attr:`Tag.ndef` is :const:`None` after the
+            update (e.g. tag gone during read or a dynamic tag that
+            failed). A robust implementation should always verify the
+            value of the :attr:`Tag.ndef` attribute. ::
+
+                if tag.ndef.has_changed and tag.ndef is not None:
+                    for record in tag.ndef.records:
+                        print(record)
+
+            The :attr:`has_changed` attribute can also be used to
+            verify that NDEF records written to the tag are identical
+            to the NDEF records stored on the tag. ::
+
+                from ndef import TextRecord
+                tag.ndef.records = [TextRecord("Hello World")]
+                if tag.ndef.has_changed:
+                    print("the tag data differs from what was written")
+
+            """
+            ndef_data = self._read_ndef_data()
+            different = self._data != ndef_data
+            if ndef_data is None:
+                self._tag._ndef = None
+            self._data = ndef_data
+            return different
+
+        @property
+        def records(self):
+            """Read or write a list of NDEF Records.
+
+            .. versionadded:: 0.12
+
+            This attribute is a convinience wrapper for decoding and
+            encoding of the NDEF message data :attr:`octets`. It uses
+            the `ndeflib <https://ndeflib.readthedocs.io>`_ module to
+            return the list of :class:`ndef.Record` instances decoded
+            from the NDEF message data or set the message data from a
+            list of records. ::
+
+                from ndef import TextRecord
+                if tag.ndef is not None:
+                    for record in tag.ndef.records:
+                        print(record)
+                    try:
+                        tag.ndef.records = [TextRecord('Hello World')]
+                    except nfc.tag.TagCommandError as err:
+                        print("NDEF write failed: " + str(err))
+
+            Decoding is performed with a relaxed error handling
+            strategy that ignores minor errors in the NDEF data. The
+            `ndeflib <https://ndeflib.readthedocs.io>`_ does also
+            support 'strict' and 'ignore' error handling which may be
+            used like so::
+
+                from ndef import message_decoder, message_encoder
+                records = message_decoder(tag.ndef.octets, errors='strict')
+                tag.ndef.octets = b''.join(message_encoder(records))
+
+            """
+            return list(message_decoder(self.octets, errors='relax'))
+
+        @records.setter
+        def records(self, value):
+            self.octets = b''.join(message_encoder(value))
+
+        @property
+        def octets(self):
+            """Read or write NDEF message data octets.
+
+            .. versionadded:: 0.12
+
+            The *octets* attribute returns the NDEF message data
+            octets as bytes. A bytes or bytearray sequence assigned to
+            *octets* is immediately written to the NDEF message data
+            area, unless the Tag memory is write protected or to
+            small. ::
+
+                if tag.ndef is not None:
+                    print(hexlify(tag.ndef.octets).decode())
+
+            """
+            return bytes(self._data)
+
+        @octets.setter
+        def octets(self, data):
+            if not self._writeable:
+                raise AttributeError("tag ndef area is not writeable")
+            data = bytearray(data)
+            if len(data) > self.capacity:
+                raise ValueError("data length exceeds tag capacity")
+            self._write_ndef_data(data)
+            self._data = data
+
+    def __init__(self, clf, target):
+        self._clf, self._target = (clf, target)
+        self._ndef = None
+        self._authenticated = False
+
+    def __str__(self):
+        """x.__str__() <==> str(x)"""
+        try:
+            s = self.type + ' ' + repr(self._product)
+        except AttributeError:
+            s = self.type
+        return "{} ID={}".format(s, hexlify(self.identifier).decode().upper())
+
+    @property
+    def clf(self):
+        return self._clf
+
+    @property
+    def target(self):
+        return self._target
+
+    @property
+    def type(self):
+        return self.TYPE
+
+    @property
+    def product(self):
+        return self._product if hasattr(self, "_product") else self.type
+
+    @property
+    def identifier(self):
+        """The unique tag identifier."""
+        return bytes(self._nfcid)
+
+    @property
+    def ndef(self):
+        """An :class:`NDEF` object if found, otherwise :const:`None`."""
+        if self._ndef is None:
+            ndef = self.NDEF(self)
+            if ndef.has_changed:
+                self._ndef = ndef
+        return self._ndef
+
+    @property
+    def is_present(self):
+        """True if the tag is within communication range."""
+        return self._is_present()
+
+    @property
+    def is_authenticated(self):
+        """True if the tag was successfully authenticated."""
+        return bool(self._authenticated)
+
+    def dump(self):
+        """The dump() method returns a list of strings describing the memory
+        structure of the tag, suitable for printing with join(). The
+        list format makes custom indentation a bit easier. ::
+
+            print("\\n".join(["\\t" + line for line in tag.dump()]))
+
+        """
+        return []
+
+    def format(self, version=None, wipe=None):
+        """Format the tag to make it NDEF compatible or erase content.
+
+        The :meth:`format` method is highly dependent on the tag type,
+        product and present status, for example a tag that has been
+        made read-only with lock bits can no longer be formatted or
+        erased.
+
+        :meth:`format` creates the management information defined by
+        the NFC Forum to describes the NDEF data area on the tag, this
+        is also called NDEF mapping. The mapping may differ between
+        versions of the tag specifications, the mapping to apply can
+        be specified with the *version* argument as an 8-bit integer
+        composed of a major version number in the most significant 4
+        bit and the minor version number in the least significant 4
+        bit. If *version* is not specified then the highest possible
+        mapping version is used.
+
+        If formatting of the tag is possible, the default behavior of
+        :meth:`format` is to update only the management information
+        required to make the tag appear as NDEF compatible and empty,
+        previously existing data could still be read. If existing data
+        shall be overwritten, the *wipe* argument can be set to an
+        8-bit integer that will be written to all available bytes.
+
+        The :meth:`format` method returns :const:`True` if formatting
+        was successful, :const:`False` if it failed for some reason,
+        or :const:`None` if the present tag can not be formatted
+        either because the tag does not support formatting or it is
+        not implemented in nfcpy.
+
+        """
+        if hasattr(self, "_format"):
+            args = "version={0!r}, wipe={1!r}"
+            args = args.format(version, wipe)
+            log.debug("format({0})".format(args))
+            status = self._format(version, wipe)
+            if status is True:
+                self._ndef = None
+            return status
+        else:
+            log.debug("this tag can not be formatted with nfcpy")
+            return None
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """Protect a tag against future write or read access.
+
+        :meth:`protect` attempts to make a tag readonly for all
+        readers if *password* is :const:`None`, writeable only after
+        authentication if a *password* is provided, and readable only
+        after authentication if a *password* is provided and the
+        *read_protect* flag is set. The *password* must be a byte or
+        character sequence that provides sufficient key material for
+        the tag specific protect function (this is documented
+        separately for the individual tag types). As a special case,
+        if *password* is set to an empty string the :meth:`protect`
+        method uses a default manufacturer value if such is known.
+
+        The *protect_from* argument sets the first memory unit to be
+        protected. Memory units are tag type specific, for a Type 1 or
+        Type 2 Tag a memory unit is 4 byte, for a Type 3 Tag it is 16
+        byte, and for a Type 4 Tag it is the complete NDEF data area.
+
+        Note that the effect of protecting a tag without password can
+        normally not be reversed.
+
+        The return value of :meth:`protect` is either :const:`True` or
+        :const:`False` depending on whether the operation was
+        successful or not, or :const:`None` if the tag does not
+        support custom protection (or it is not implemented).
+
+        """
+        if hasattr(self, "_protect"):
+            args = "password={0!r}, read_protect={1!r}, protect_from={2!r}"
+            args = args.format(password, read_protect, protect_from)
+            log.debug("protect({0})".format(args))
+            status = self._protect(password, read_protect, protect_from)
+            if status is True:
+                self._ndef = None
+            return status
+        else:
+            log.error("this tag can not be protected with nfcpy")
+            return None
+
+    def authenticate(self, password):
+        """Authenticate a tag with a *password*.
+
+        A tag that was once protected with a password requires
+        authentication before write, potentially also read, operations
+        may be performed. The *password* must be the same as the
+        password provided to :meth:`protect`. The return value
+        indicates authentication success with :const:`True` or
+        :const:`False`. For a tag that does not support authentication
+        the return value is :const:`None`.
+
+        """
+        if hasattr(self, "_authenticate"):
+            args = "password={0!r}".format(password)
+            log.debug("authenticate({0})".format(args))
+            self._authenticated = self._authenticate(password)
+            if self._authenticated is True:
+                self._ndef = None
+            return self._authenticated
+        else:
+            log.error("this tag can not be authenticated with nfcpy")
+            return None
+
+
+TIMEOUT_ERROR = 0
+RECEIVE_ERROR = -1
+PROTOCOL_ERROR = -2
+
+
+class TagCommandError(Exception):
+    """The base class for exceptions that are raised when a tag command
+    has not returned the expected result or a a lower stack error was
+    raised.
+
+    The :attr:`errno` attribute holds a reason code for why the
+    command has failed. Error numbers greater than zero indicate a tag
+    type specific error from one of the exception classes derived from
+    :exc:`TagCommandError` (per tag type module). Error numbers below
+    and including zero indicate general errors::
+
+        nfc.tag.TIMEOUT_ERROR  => unrecoverable timeout error
+        nfc.tag.RECEIVE_ERROR  => unrecoverable transmission error
+        nfc.tag.PROTOCOL_ERROR => unrecoverable protocol error
+
+    The :exc:`TagCommandError` exception populates the *message*
+    attribute of the general exception class with the appropriate
+    error description.
+
+    """
+    errno_str = {
+        TIMEOUT_ERROR: "unrecoverable timeout error",
+        RECEIVE_ERROR: "unrecoverable transmission error",
+        PROTOCOL_ERROR: "unrecoverable protocol error",
+    }
+
+    def __init__(self, errno):
+        default = "tag command error {errno} (0x{errno:x})".format(errno=errno)
+        if errno > 0:
+            message = self.errno_str.get(errno, default)
+        else:
+            message = TagCommandError.errno_str.get(errno, default)
+        super(TagCommandError, self).__init__(message)
+        self._errno = errno
+
+    @property
+    def errno(self):
+        """Holds the error reason code."""
+        return self._errno
+
+    def __int__(self):
+        return self._errno
+
+
+def activate(clf, target):
+    import src.lib.nfc.clf
+    try:
+        log.debug("trying to activate {0}".format(target))
+        if target.brty.endswith('A'):
+            if target.sens_res[1] & 0x0F == 0x0C:
+                return activate_tt1(clf, target)
+            elif target.sel_res[0] >> 5 & 3 == 0:
+                return activate_tt2(clf, target)
+            elif target.sel_res[0] >> 5 & 1 == 1:
+                return activate_tt4(clf, target)
+        elif target.brty.endswith('B'):
+            return activate_tt4(clf, target)
+        elif target.brty.endswith('F'):
+            return activate_tt3(clf, target)
+    except src.lib.nfc.clf.CommunicationError:
+        return None
+
+
+def activate_tt1(clf, target):
+    log.debug("trying type 1 tag activation for {0}".format(target.brty))
+    import src.lib.nfc.tag.tt1
+    return src.lib.nfc.tag.tt1.activate(clf, target)
+
+
+def activate_tt2(clf, target):
+    log.debug("trying type 2 tag activation for {0}".format(target.brty))
+    import src.lib.nfc.tag.tt2
+    return src.lib.nfc.tag.tt2.activate(clf, target)
+
+
+def activate_tt3(clf, target):
+    log.debug("trying type 3 tag activation for {0}".format(target.brty))
+    import src.lib.nfc.tag.tt3
+    return src.lib.nfc.tag.tt3.activate(clf, target)
+
+
+def activate_tt4(clf, target):
+    log.debug("trying type 4 tag activation for {0}".format(target.brty))
+    import src.lib.nfc.tag.tt4
+    return src.lib.nfc.tag.tt4.activate(clf, target)
+
+
+class TagEmulation(object):
+    """Base class for tag emulation classes."""
+    pass
+
+
+def emulate(clf, target):
+    import src.lib.nfc.clf
+    assert isinstance(target, src.lib.nfc.clf.LocalTarget)
+    if target.tt3_cmd:
+        import src.lib.nfc.tag.tt3
+        return src.lib.nfc.tag.tt3.Type3TagEmulation(clf, target)
+    else:
+        log.debug("can't emulate with %s", target)

src/lib/nfc/tag/tt1.py

@@ -0,0 +1,555 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2011, 2017
+#   Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#   Alexander Knaub <sanyok.og@googlemail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 time
+from binascii import hexlify
+from struct import pack, unpack
+
+from . import Tag, TagCommandError
+import nfc.clf
+
+import logging
+log = logging.getLogger(__name__)
+
+
+CHECKSUM_ERROR, RESPONSE_ERROR, WRITE_ERROR, \
+    BLOCK_ERROR, SECTOR_ERROR = range(1, 6)
+
+
+class Type1TagCommandError(TagCommandError):
+    """Type 1 Tag specific exceptions. Sets
+    :attr:`~nfc.tag.TagCommandError.errno` to one of:
+
+    | 1 - CHECKSUM_ERROR
+    | 2 - RESPONSE_ERROR
+    | 3 - WRITE_ERROR
+
+    """
+    errno_str = {
+        CHECKSUM_ERROR: "crc validation failed",
+        RESPONSE_ERROR: "invalid response data",
+        WRITE_ERROR: "data write failure",
+    }
+
+
+def read_tlv(memory, offset, skip_bytes):
+    # Unpack a TLV from tag memory and return tag type, tag length and
+    # tag value. For tag type 0 there is no length field, this is
+    # returned as length -1. The tlv length field can be one or three
+    # bytes, if the first byte is 255 then the next two byte carry the
+    # length (big endian).
+    try:
+        tlv_t, offset = (memory[offset], offset+1)
+    except Type1TagCommandError:
+        return (None, None, None)
+
+    if tlv_t in (0x00, 0xFE):
+        return (tlv_t, -1, None)
+
+    tlv_l, offset = (memory[offset], offset+1)
+
+    if tlv_l == 0xFF:
+        tlv_l, offset = (unpack(">H", memory[offset:offset+2])[0], offset+2)
+
+    tlv_v = bytearray(tlv_l)
+    for i in range(tlv_l):
+        while (offset + i) in skip_bytes:
+            offset += 1
+        tlv_v[i] = memory[offset+i]
+
+    return (tlv_t, tlv_l, tlv_v)
+
+
+def get_lock_byte_range(data):
+    # Extract the lock byte range indicated by a Lock Control TLV. The
+    # data argument is the TLV value field.
+    page_addr = data[0] >> 4
+    byte_offs = data[0] & 0x0F
+    rsvd_size = ((data[1] if data[1] > 0 else 256) + 7) // 8
+    page_size = 2 ** (data[2] & 0x0F)
+    rsvd_from = page_addr * page_size + byte_offs
+    return slice(rsvd_from, rsvd_from + rsvd_size)
+
+
+def get_rsvd_byte_range(data):
+    # Extract the reserved memory range indicated by a Memory Control
+    # TLV. The data argument is the TLV value field.
+    page_addr = data[0] >> 4
+    byte_offs = data[0] & 0x0F
+    rsvd_size = data[1] if data[1] > 0 else 256
+    page_size = 2 ** (data[2] & 0x0F)
+    rsvd_from = page_addr * page_size + byte_offs
+    return slice(rsvd_from, rsvd_from + rsvd_size)
+
+
+def get_capacity(tag_memory_size, offset, skip_bytes):
+    # The net capacity is the range of bytes from the current offset
+    # until the end of user data bytes (given by the capability
+    # container capacity value plus 16 header bytes), reduced by the
+    # number of skip bytes (from memory and lock control TLVs) that
+    # are within the usable memory range, and adjusted by the required
+    # number of TLV length bytes (1 or 3) and the TLV tag byte.
+    log.debug("subtract {0} skip bytes from capacity".format(len(skip_bytes)))
+    capacity = len(set(range(offset, tag_memory_size)) - skip_bytes)
+    # To store more than 254 byte ndef we must use three length bytes,
+    # otherwise it's only one. But only if the capacity is more than
+    # 256 the three length byte format will provide a higher value.
+    capacity -= 4 if capacity > 256 else 2
+    return capacity
+
+
+class Type1Tag(Tag):
+    """Implementation of the NFC Forum Type 1 Tag Operation specification.
+
+    The NFC Forum Type 1 Tag is based on the ISO 14443 Type A
+    technology for frame structure and anticollision (detection)
+    commands, and the Innovision (now Broadcom) Jewel/Topaz commands
+    for accessing the tag memory.
+
+    """
+    TYPE = "Type1Tag"
+
+    class NDEF(Tag.NDEF):
+        # Type 1 Tag specific implementation of the NDEF access type
+        # class that is returned by the Tag.ndef attribute.
+
+        def __init__(self, tag):
+            super(Type1Tag.NDEF, self).__init__(tag)
+            self._ndef_tlv_offset = 0
+
+        def _read_ndef_data(self):
+            # Check and read ndef data from tag. Return None if the
+            # tag is not ndef formatted, i.e. it can not hold ndef
+            # data or does not have (valid) ndef management data.
+            # Otherwise, set state variables and return the ndef
+            # message data as a bytearray (may be zero length).
+            log.debug("read ndef data")
+            try:
+                tag_memory = Type1TagMemoryReader(self.tag)
+
+                if tag_memory._header_rom[0] >> 4 != 1:
+                    log.debug("proprietary type 1 tag memory structure")
+                    return None
+
+                if tag_memory[8] != 0xE1:
+                    log.debug("ndef management data is not present")
+                    return None
+
+                if tag_memory[9] >> 4 != 1:
+                    log.debug("unsupported ndef mapping version")
+                    return None
+
+                self._readable = bool(tag_memory[11] >> 4 == 0)
+                self._writeable = bool(tag_memory[11] & 0xF == 0)
+
+                tag_memory_size = (tag_memory[10] + 1) * 8
+                log.debug("tag memory size is %d byte" % tag_memory_size)
+            except Type1TagCommandError:
+                log.debug("header rom and static memory were unreadable")
+                return None
+
+            ndef = None
+            offset = 12
+            skip_end = 120 if tag_memory_size == 120 else 128
+            skip_bytes = set(range(104, skip_end))
+            while offset < tag_memory_size:
+                if offset in skip_bytes:
+                    offset += 1
+                    continue
+
+                tlv_t, tlv_l, tlv_v = read_tlv(tag_memory, offset, skip_bytes)
+                log.debug("tlv type {0} at address {1}".format(tlv_t, offset))
+
+                if tlv_t == 0x00:
+                    pass
+                elif tlv_t == 0x01:
+                    lock_bytes = get_lock_byte_range(tlv_v)
+                    skip_bytes.update(range(*lock_bytes.indices(0x800)))
+                elif tlv_t == 0x02:
+                    rsvd_bytes = get_rsvd_byte_range(tlv_v)
+                    skip_bytes.update(range(*rsvd_bytes.indices(0x800)))
+                elif tlv_t == 0x03:
+                    ndef = tlv_v
+                    break
+                elif tlv_t == 0xFE or tlv_t is None:
+                    break
+                else:
+                    logmsg = "unknown tlv {0} at offset {0}"
+                    log.debug(logmsg.format(tlv_t, offset))
+
+                offset += tlv_l + 1 + (1 if tlv_l < 255 else 3)
+
+            self._capacity = get_capacity(tag_memory_size, offset, skip_bytes)
+            self._ndef_tlv_offset = offset
+            self._tag_memory = tag_memory
+            self._skip_bytes = skip_bytes
+            return ndef
+
+        def _write_ndef_data(self, data):
+            log.debug("write ndef data {0}{1}".format(
+                hexlify(data[:10]).decode(), '...' if len(data) > 10 else ''))
+
+            tag_memory = self._tag_memory
+            skip_bytes = self._skip_bytes
+            offset = self._ndef_tlv_offset
+            tag_memory_size = (tag_memory[10] + 1) * 8
+
+            # Set the ndef message tlv length to 0.
+            tag_memory[offset+1] = 0
+            tag_memory.synchronize()
+
+            # Leave room for ndef message length byte(s) and write
+            # ndef data into the memory image, but jump over skip
+            # bytes.
+            offset += 2 if len(data) < 255 else 4
+            for i in range(len(data)):
+                while offset + i in skip_bytes:
+                    offset += 1
+                tag_memory[offset+i] = data[i]
+            # Write a terminator tlv if space permits. We may have to
+            # skip reserved and lock bytes.
+            offset = offset + i + 1
+            while offset < tag_memory_size:
+                if offset not in skip_bytes:
+                    tag_memory[offset] = 0xFE
+                    break
+                offset += 1
+            # Write the new message data to the tag.
+            tag_memory.synchronize()
+
+            # Write the ndef message tlv length.
+            offset = self._ndef_tlv_offset
+            if len(data) < 255:
+                tag_memory[offset+1] = len(data)
+            else:
+                tag_memory[offset+1] = 0xFF
+                tag_memory[offset+2:offset+4] = pack(">H", len(data))
+            tag_memory.synchronize()
+
+    #
+    # Type1Tag methods and attributes
+    #
+    def __init__(self, clf, target):
+        super(Type1Tag, self).__init__(clf, target)
+        self._nfcid = self.uid = target.rid_res[2:6]
+
+    def dump(self):
+        """Returns the tag memory blocks as a list of formatted strings.
+
+        :meth:`dump` iterates over all tag memory blocks (8 bytes
+        each) from block zero until the physical end of memory and
+        produces a list of strings that is intended for line by line
+        printing. Multiple consecutive memory block of identical
+        content may be reduced to fewer lines of output, so the number
+        of lines returned does not necessarily correspond to the
+        number of memory blocks present.
+
+        .. warning:: For tags with more than 120 byte memory, the
+            dump() method first overwrites the data block to verify
+            that it is backed by physical memory, then restores the
+            original data. This is necessary because Type 1 Tags do
+            not indicate an error when reading beyond the physical
+            memory space. Be cautious to not remove a tag from the
+            reader when using dump() as otherwise your data may be
+            corrupted.
+
+        """
+        return self._dump(stop=None)
+
+    def _dump(self, stop=None):
+        # Read and print all data blocks until the non-inclusive stop
+        # block number. Type 1 Tags with dynamic memory seem to return
+        # data for every address, regardless of whether there is
+        # memory mapped or not. To show exactly the memory blocks that
+        # are physically present, blocks from 16-end are first
+        # overwritten with an inverted version of the content and then
+        # recovered. Because WRITE8 returns the new data content, a
+        # non-existing block can be detected.
+
+        def oprint(octets):
+            return ' '.join(['??' if x < 0 else '%02x' % x for x in octets])
+
+        def cprint(octets):
+            return ''.join([chr(x) if 32 <= x <= 126 else '.' for x in octets])
+
+        def lprint(fmt, d, i):
+            return fmt.format(i, oprint(d), cprint(d))
+
+        txt = ["UID0-UID6, RESERVED", "RESERVED", "LOCK0-LOCK1, OTP0-OTP5",
+               "LOCK2-LOCK3, RESERVED"]
+
+        lines = list()
+        data = self.read_all()
+        hrom, data = data[0:2], data[2:]
+
+        lines.append("HR0={0:02X}h, HR1={1:02X}h".format(*hrom))
+        lines.append("  0: {0} ({1})".format(oprint(data[0:8]), txt[0]))
+        for i in range(8, 104, 8):
+            lines.append(lprint("{0:3}: {1} |{2}|", data[i:i+8], i//8))
+        lines.append(" 13: {0} ({1})".format(oprint(data[104:112]), txt[1]))
+        lines.append(" 14: {0} ({1})".format(oprint(data[112:120]), txt[2]))
+
+        if stop is None or stop > 15:
+            try:
+                data = self.read_block(15)
+            except Type1TagCommandError:
+                return lines
+            else:
+                lines.append(" 15: {0} ({1})".format(oprint(data), txt[3]))
+
+        data_line_fmt = "{0:>3}: {1} |{2}|"
+        same_line_fmt = "{0:>3}  {1} |{2}|"
+        this_data = last_data = None
+        same_data = 0
+
+        def dump_same_data(same_data, last_data, this_data, page):
+            if same_data > 1:
+                lines.append(lprint(same_line_fmt, last_data, "*"))
+            if same_data > 0:
+                lines.append(lprint(data_line_fmt, this_data, page))
+
+        for i in range(16, stop if stop is not None else 256):
+            try:
+                this_data = self.read_block(i)
+                if stop is None:
+                    test_data = bytearray([b ^ 0xFF for b in this_data])
+                    self.write_block(i, test_data)
+                    self.write_block(i, this_data)
+            except Type1TagCommandError:
+                dump_same_data(same_data, last_data, this_data, i-1)
+                break
+
+            if this_data == last_data:
+                same_data += 1
+            else:
+                dump_same_data(same_data, last_data, last_data, i-1)
+                lines.append(lprint(data_line_fmt, this_data, i))
+                last_data = this_data
+                same_data = 0
+        else:
+            dump_same_data(same_data, last_data, this_data, i)
+
+        return lines
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """The implementation of :meth:`nfc.tag.Tag.protect` for a generic
+        type 1 tag is limited to setting the NDEF data read-only for
+        tags that are already NDEF formatted.
+
+        """
+        return super(Type1Tag, self).protect(
+            password, read_protect, protect_from)
+
+    def _protect(self, password, read_protect, protect_from):
+        if password is None:
+            if self.ndef is not None:
+                self.write_byte(11, 0x0F, erase=False)
+                return True
+            else:
+                log.warning("no ndef, can't set write access restriction")
+        else:
+            log.warning("this tag can not be protected with a password")
+        return False
+
+    def _is_present(self):
+        try:
+            return self.read_byte(0) == self.uid[0]
+        except Type1TagCommandError:
+            return False
+
+    def read_id(self):
+        """Returns the 2 byte Header ROM and 4 byte UID.
+        """
+        log.debug("read identification")
+        cmd = b"\x78\x00\x00\x00\x00\x00\x00"
+        return self.transceive(cmd)
+
+    def read_all(self):
+        """Returns the 2 byte Header ROM and all 120 byte static memory.
+        """
+        log.debug("read all static memory")
+        cmd = b"\x00\x00\x00" + self.uid
+        return self.transceive(cmd)
+
+    def read_byte(self, addr):
+        """Read a single byte from static memory area (blocks 0-14).
+        """
+        if addr < 0 or addr > 127:
+            raise ValueError("invalid byte address")
+        log.debug("read byte at address {0} ({0:02X}h)".format(addr))
+        cmd = bytearray([0x01, addr, 0x00]) + self.uid
+        return self.transceive(cmd)[-1]
+
+    def read_block(self, block):
+        """Read an 8-byte data block at address (block * 8).
+        """
+        if block < 0 or block > 255:
+            raise ValueError("invalid block number")
+        log.debug("read block {0}".format(block))
+        cmd = bytearray([0x02, block] + [0x00 for _ in range(8)]) + self.uid
+        return self.transceive(cmd)[1:9]
+
+    def read_segment(self, segment):
+        """Read one memory segment (128 byte).
+        """
+        log.debug("read segment {0}".format(segment))
+        if segment < 0 or segment > 15:
+            raise ValueError("invalid segment number")
+        cmd = bytearray([0x10, segment << 4] + [0x00 for _ in range(8)]) \
+            + self.uid
+        rsp = self.transceive(cmd)
+        if len(rsp) < 129:
+            raise Type1TagCommandError(RESPONSE_ERROR)
+        return rsp[1:129]
+
+    def write_byte(self, addr, data, erase=True):
+        """Write a single byte to static memory area (blocks 0-14). The
+        target byte is zero'd first if *erase* is True.
+
+        """
+        if addr < 0 or addr >= 128:
+            raise ValueError("invalid byte address")
+        log.debug("write byte at address {0} ({0:02X}h)".format(addr))
+        cmd = b"\x53" if erase is True else b"\x1A"
+        cmd = cmd + bytearray([addr, data]) + self.uid
+        return self.transceive(cmd)
+
+    def write_block(self, block, data, erase=True):
+        """Write an 8-byte data block at address (block * 8). The target
+        bytes are zero'd first if *erase* is True.
+
+        """
+        if block < 0 or block > 255:
+            raise ValueError("invalid block number")
+        log.debug("write block {0}".format(block))
+        cmd = b"\x54" if erase is True else b"\x1B"
+        cmd = cmd + bytearray([block]) + data + self.uid
+        rsp = self.transceive(cmd)
+        if len(rsp) < 9:
+            raise Type1TagCommandError(RESPONSE_ERROR)
+        if erase is True and rsp[1:9] != data:
+            raise Type1TagCommandError(WRITE_ERROR)
+
+    def transceive(self, data, timeout=0.1):
+        log.debug(">> {0} ({1:f}s)".format(hexlify(data).decode(), timeout))
+
+        started = time.time()
+        error = None
+        for retry in range(3):
+            try:
+                data = self.clf.exchange(data, timeout)
+                break
+            except nfc.clf.CommunicationError as e:
+                error = e
+                reason = error.__class__.__name__
+                log.debug("%s after %d retries" % (reason, retry))
+        else:
+            if type(error) is nfc.clf.TimeoutError:
+                raise Type1TagCommandError(nfc.tag.TIMEOUT_ERROR)
+            if type(error) is nfc.clf.TransmissionError:
+                raise Type1TagCommandError(nfc.tag.RECEIVE_ERROR)
+            if type(error) is nfc.clf.ProtocolError:
+                raise Type1TagCommandError(nfc.tag.PROTOCOL_ERROR)
+            raise RuntimeError("unexpected " + repr(error))
+
+        elapsed = time.time() - started
+        log.debug("<< {0} ({1:f}s)".format(hexlify(data).decode(), elapsed))
+        return data
+
+
+class Type1TagMemoryReader(object):
+    def __init__(self, tag):
+        assert isinstance(tag, Type1Tag)
+        self._data_from_tag = bytearray()
+        self._data_in_cache = bytearray()
+        self._tag = tag
+        self._header_rom = bytearray(0)
+        # read header_rom and static memory
+        self._read_from_tag(1)
+
+    def __len__(self):
+        return len(self._data_from_tag)
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            start, stop, step = key.indices(0x100000)
+            if stop > len(self):
+                self._read_from_tag(stop)
+        elif key >= len(self):
+            self._read_from_tag(stop=key+1)
+        return self._data_in_cache[key]
+
+    def __setitem__(self, key, value):
+        self.__getitem__(key)
+        if isinstance(key, slice):
+            if len(value) != len(range(*key.indices(0x100000))):
+                msg = "{cls} requires item assignment of identical length"
+                raise ValueError(msg.format(cls=self.__class__.__name__))
+        self._data_in_cache[key] = value
+        del self._data_in_cache[len(self):]
+
+    def __delitem__(self, key):
+        msg = "{cls} object does not support item deletion"
+        raise TypeError(msg.format(cls=self.__class__.__name__))
+
+    def _read_from_tag(self, stop):
+        if len(self) < 120:
+            read_all_data_response = self._tag.read_all()
+            self._header_rom = read_all_data_response[0:2]
+            self._data_from_tag[0:] = read_all_data_response[2:]
+            self._data_in_cache[0:] = self._data_from_tag[0:]
+
+        if stop > 120 and len(self) < 128:
+            read_block_response = self._tag.read_block(15)
+            self._data_from_tag[120:128] = read_block_response
+            self._data_in_cache[120:128] = read_block_response
+
+        while len(self) < stop:
+            data = self._tag.read_segment(len(self) >> 7)
+            self._data_from_tag.extend(data)
+            self._data_in_cache.extend(data)
+
+    def _write_to_tag(self, stop):
+        hr0 = self._header_rom[0]
+        if hr0 >> 4 == 1 and hr0 & 0x0F != 1:
+            for i in range(0, stop, 8):
+                data = self._data_in_cache[i:i+8]
+                if data != self._data_from_tag[i:i+8]:
+                    self._tag.write_block(i//8, data)
+                    self._data_from_tag[i:i+8] = data
+        else:
+            for i in range(0, stop):
+                data = self._data_in_cache[i]
+                if data != self._data_from_tag[i]:
+                    self._tag.write_byte(i, data)
+                    self._data_from_tag[i] = data
+
+    def synchronize(self):
+        """Write pages that contain modified data back to tag memory."""
+        self._write_to_tag(stop=len(self))
+
+
+def activate(clf, target):
+    import nfc.tag.tt1_broadcom
+    tag = nfc.tag.tt1_broadcom.activate(clf, target)
+    return tag if tag is not None else Type1Tag(clf, target)

src/lib/nfc/tag/tt1_broadcom.py

@@ -0,0 +1,159 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2014, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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.
+# -----------------------------------------------------------------------------
+from . import tt1
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Topaz(tt1.Type1Tag):
+    """The Broadcom Topaz is a small memory tag that can hold up to 94
+    byte ndef message data.
+
+    """
+    def __init__(self, clf, target):
+        super(Topaz, self).__init__(clf, target)
+        self._product = "Topaz (BCM20203T96)"
+
+    def dump(self):
+        return super(Topaz, self)._dump(stop=15)
+
+    def format(self, version=None, wipe=None):
+        """Format a Topaz tag for NDEF use.
+
+        The implementation of :meth:`nfc.tag.Tag.format` for a Topaz
+        tag creates a capability container and an NDEF TLV with length
+        zero. Data bytes of the NDEF data area are left untouched
+        unless the wipe argument is set.
+
+        """
+        return super(Topaz, self).format(version, wipe)
+
+    def _format(self, version, wipe):
+        tag_memory = tt1.Type1TagMemoryReader(self)
+        tag_memory[8:14] = b"\xE1\x10\x0E\x00\x03\x00"
+
+        if version is not None:
+            if version >> 4 == 1:
+                tag_memory[9] = version
+            else:
+                log.warning("can not format with major version != 1")
+                return False
+
+        if wipe is not None:
+            tag_memory[14:104] = bytearray([wipe & 0xFF]) * 90
+
+        tag_memory.synchronize()
+        return True
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """In addtion to :meth:`nfc.tag.tt1.Type1Tag.protect` this method
+        tries to set the lock bits to irreversibly protect the tag
+        memory. However, it appears that tags sold have the lock bytes
+        write protected, so this additional effort most likely doesn't
+        have any effect.
+
+        """
+        return super(Topaz, self).protect(
+            password, read_protect, protect_from)
+
+    def _protect(self, password, read_protect, protect_from):
+        if super(Topaz, self)._protect(password, read_protect, protect_from):
+            self.write_byte(112, 0xFF, erase=False)
+            self.write_byte(113, 0xFF, erase=False)
+            return True
+        else:
+            return False
+
+
+class Topaz512(tt1.Type1Tag):
+    """The Broadcom Topaz-512 is a memory enhanced version that can hold
+    up to 462 byte ndef message data.
+
+    """
+    def __init__(self, clf, target):
+        super(Topaz512, self).__init__(clf, target)
+        self._product = "Topaz 512 (BCM20203T512)"
+
+    def dump(self):
+        return super(Topaz512, self)._dump(stop=64)
+
+    def format(self, version=None, wipe=None):
+        """Format a Topaz-512 tag for NDEF use.
+
+        The implementation of :meth:`nfc.tag.Tag.format` for a
+        Topaz-512 tag creates a capability container, a Lock Control
+        and a Memory Control TLV, and an NDEF TLV with length
+        zero. Data bytes of the NDEF data area are left untouched
+        unless the wipe argument is set.
+
+        """
+        return super(Topaz512, self).format(version, wipe)
+
+    def _format(self, version, wipe):
+        tag_memory = tt1.Type1TagMemoryReader(self)
+        tag_memory[8:16] = bytearray.fromhex("E1103F000103F230")
+        tag_memory[16:24] = bytearray.fromhex("330203F002030300")
+
+        if version is not None:
+            if version >> 4 == 1:
+                tag_memory[9] = version
+            else:
+                log.warning("can not format with major version != 1")
+                return False
+
+        if wipe is not None:
+            tag_memory[24:104] = bytearray([wipe & 0xFF]) * 80
+            tag_memory[128:512] = bytearray([wipe & 0xFF]) * 384
+
+        tag_memory.synchronize()
+        return True
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """In addtion to :meth:`nfc.tag.tt1.Type1Tag.protect` this method
+        tries to set the lock bits to irreversibly protect the tag
+        memory. However, it appears that tags sold have the lock bytes
+        write protected, so this additional effort most likely doesn't
+        have any effect.
+
+        """
+        return super(Topaz512, self).protect(
+            password, read_protect, protect_from)
+
+    def _protect(self, password, read_protect, protect_from):
+        if super(Topaz512, self)._protect(
+                password, read_protect, protect_from):
+            self.write_byte(112, 0xFF, erase=False)
+            self.write_byte(113, 0xFF, erase=False)
+            self.write_byte(120, 0xFF, erase=False)
+            self.write_byte(121, 0xFF, erase=False)
+            return True
+        else:
+            return False
+
+
+def activate(clf, target):
+    hrom = target.rid_res[0:2]
+    if hrom == b"\x11\x48":
+        return Topaz(clf, target)
+    if hrom == b"\x12\x4C":
+        return Topaz512(clf, target)

src/lib/nfc/tag/tt2.py

@@ -0,0 +1,697 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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.
+# Licensed under the EUPL, Version 1.1 or - as soon they
+# You may obtain a copy of the Licence at:
+#
+
+# https://joinup.ec.europa.eu/software/page/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 time
+from binascii import hexlify
+from struct import pack, unpack
+
+from . import Tag, TagCommandError
+import src.lib.nfc.clf
+
+import logging
+log = logging.getLogger(__name__)
+
+
+def hexdump(octets, sep=""):
+    return sep.join(
+        ("??" if x is None else ("%02x" % x)) for x in octets)
+
+
+def chrdump(octets, sep=""):
+    return sep.join(
+            (("{:c}".format(x) if 32 <= x <= 126 else ".")
+             if x is not None
+             else ".")
+            for x in octets)
+
+
+def pagedump(page, octets, info=None):
+    info = ("|%s|" % chrdump(octets)) if info is None else ("(%s)" % info)
+    page = "  * " if page is None else "{0:03X}:".format(page)
+    return "{0} {1} {2}".format(page, hexdump(octets, sep=" "), info)
+
+
+TIMEOUT_ERROR, INVALID_SECTOR_ERROR, \
+    INVALID_PAGE_ERROR, INVALID_RESPONSE_ERROR = range(4)
+
+
+class Type2TagCommandError(TagCommandError):
+    """Type 2 Tag specific exceptions. Sets
+    :attr:`~nfc.tag.TagCommandError.errno` to one of:
+
+    | 1 - INVALID_SECTOR_ERROR
+    | 2 - INVALID_PAGE_ERROR
+    | 3 - INVALID_RESPONSE_ERROR
+
+    """
+    errno_str = {
+        INVALID_SECTOR_ERROR: "invalid sector number",
+        INVALID_PAGE_ERROR: "invalid page number",
+        INVALID_RESPONSE_ERROR: "invalid response data",
+    }
+
+
+def read_tlv(memory, offset, skip_bytes):
+    # Unpack a Type 2 Tag TLV from tag memory and return tag type, tag
+    # length and tag value. For tag type 0 there is no length field,
+    # this is returned as length -1. The tlv length field can be one
+    # or three bytes, if the first byte is 255 then the next two byte
+    # carry the length (big endian).
+    tlv_t, offset = (memory[offset], offset+1)
+    if tlv_t in (0x00, 0xFE):
+        return (tlv_t, -1, None)
+    tlv_l, offset = (memory[offset], offset+1)
+    if tlv_l == 0xFF:
+        tlv_l, offset = (unpack(">H", memory[offset:offset+2])[0], offset+2)
+    tlv_v = bytearray(tlv_l)
+    for i in range(tlv_l):
+        while (offset + i) in skip_bytes:
+            offset += 1
+        tlv_v[i] = memory[offset+i]
+    return (tlv_t, tlv_l, tlv_v)
+
+
+def get_lock_byte_range(data):
+    # Extract the lock byte range indicated by a Lock Control TLV. The
+    # data argument is the TLV value field.
+    page_addr = data[0] >> 4
+    byte_offs = data[0] & 0x0F
+    rsvd_size = ((data[1] if data[1] > 0 else 256) + 7) // 8
+    page_size = 2 ** (data[2] & 0x0F)
+    rsvd_from = page_addr * page_size + byte_offs
+    return slice(rsvd_from, rsvd_from + rsvd_size)
+
+
+def get_rsvd_byte_range(data):
+    # Extract the reserved memory range indicated by a Memory Control
+    # TLV. The data argument is the TLV value field.
+    page_addr = data[0] >> 4
+    byte_offs = data[0] & 0x0F
+    rsvd_size = data[1] if data[1] > 0 else 256
+    page_size = 2 ** (data[2] & 0x0F)
+    rsvd_from = page_addr * page_size + byte_offs
+    return slice(rsvd_from, rsvd_from + rsvd_size)
+
+
+def get_capacity(capacity, offset, skip_bytes):
+    # The net capacity is the range of bytes from the current offset
+    # until the end of user data bytes (given by the capability
+    # container capacity value plus 16 header bytes), reduced by the
+    # number of skip bytes (from memory and lock control TLVs) that
+    # are within the usable memory range, and adjusted by the required
+    # number of TLV length bytes (1 or 3) and the TLV tag byte.
+    capacity = len(set(range(offset, capacity + 16)) - skip_bytes)
+    # To store more than 254 byte ndef we must use three length bytes,
+    # otherwise it's only one. But only if the capacity is more than
+    # 256 the three length byte format will provide a higher value.
+    capacity -= 4 if capacity > 256 else 2
+    return capacity
+
+
+class Type2Tag(Tag):
+    """Implementation of the NFC Forum Type 2 Tag Operation specification.
+
+    The NFC Forum Type 2 Tag is based on the ISO 14443 Type A
+    technology for frame structure and anticollision (detection)
+    commands, and the NXP Mifare commands for accessing the tag
+    memory.
+
+    """
+    TYPE = "Type2Tag"
+
+    class NDEF(Tag.NDEF):
+        # Type 2 Tag specific implementation of the NDEF access type
+        # class that is returned by the Tag.ndef attribute.
+
+        def __init__(self, tag):
+            super(Type2Tag.NDEF, self).__init__(tag)
+            self._ndef_tlv_offset = 0
+
+        def _read_capability_data(self, tag_memory):
+            try:
+                if tag_memory[12] != 0xE1:
+                    log.debug("ndef management data is not present")
+                    return False
+                if tag_memory[13] >> 4 != 1:
+                    log.debug("unsupported ndef mapping major version")
+                    return False
+                self._readable = bool(tag_memory[15] >> 4 == 0)
+                self._writeable = bool(tag_memory[15] & 0xF == 0)
+                return True
+            except Type2TagCommandError:
+                log.debug("first four memory pages were unreadable")
+                return False
+
+        def _read_ndef_data(self):
+            log.debug("read ndef data")
+            tag_memory = Type2TagMemoryReader(self.tag)
+
+            if not self._read_capability_data(tag_memory):
+                return None
+
+            raw_capacity = tag_memory[14] * 8
+            log.debug("raw capacity is {0} byte".format(raw_capacity))
+
+            offset = 16
+            ndef = None
+            skip_bytes = set()
+            data_area_size = raw_capacity
+            while offset < data_area_size + 16:
+                while (offset) in skip_bytes:
+                    offset += 1
+
+                try:
+                    tlv = read_tlv(tag_memory, offset, skip_bytes)
+                    tlv_t, tlv_l, tlv_v = tlv
+                except Type2TagCommandError:
+                    return None
+                else:
+                    logmsg = "tlv type {0} length {1} at offset {2}"
+                    log.debug(logmsg.format(tlv_t, tlv_l, offset))
+
+                if tlv_t == 0:
+                    pass
+                elif tlv_t == 1:
+                    if tlv_l == 3:
+                        lock_bytes = get_lock_byte_range(tlv_v)
+                        skip_bytes.update(range(*lock_bytes.indices(0x100000)))
+                    else:
+                        log.debug("lock tlv has wrong length")
+                elif tlv_t == 2:
+                    if tlv_l == 3:
+                        rsvd_bytes = get_rsvd_byte_range(tlv_v)
+                        skip_bytes.update(range(*rsvd_bytes.indices(0x100000)))
+                    else:
+                        log.debug("memory tlv has wrong length")
+                elif tlv_t == 3:
+                    ndef = tlv_v
+                    break
+                elif tlv_t == 254:
+                    break
+                else:
+                    logmsg = "unknown tlv {0} at offset {0}"
+                    log.debug(logmsg.format(tlv_t, offset))
+
+                offset += tlv_l + 1 + (1 if tlv_l < 255 else 3)
+
+            self._capacity = get_capacity(raw_capacity, offset, skip_bytes)
+            self._ndef_tlv_offset = offset
+            self._tag_memory = tag_memory
+            self._skip_bytes = skip_bytes
+            return ndef
+
+        def _write_ndef_data(self, data):
+            # Write new ndef data to the tag memory. Despite the
+            # tag memory is rather easy to handle, the extremely
+            # generic NFC Forum TLV structure makes this rather
+            # complicated. The precondition is that we have already
+            # processed the memory structure in _read_ndef_data(), if
+            # not we'll do it first. We'll then have a tag memory
+            # image, know which bytes need to be to skipped as told by
+            # memory or control tlv data, and where the ndef message
+            # tlv starts. We first set the ndef message tlv length to
+            # zero (synchronize cause that to be actually written),
+            # then write all new data into the memory image (skipping
+            # bytes as needed) and let that be written to the tag, and
+            # finally write the new ndef message tlv length.
+            log.debug("write ndef data {0}{1}".format(
+                hexlify(data[:10]).decode(), '...' if len(data) > 10 else ''))
+
+            tag_memory = self._tag_memory
+            skip_bytes = self._skip_bytes
+            offset = self._ndef_tlv_offset
+
+            # Set the ndef message tlv length to 0.
+            tag_memory[offset+1] = 0
+            tag_memory.synchronize()
+
+            # Leave room for ndef message length byte(s) and write
+            # ndef data into the memory image, but jump over skip
+            # bytes. If space permits, write a terminator tlv.
+            offset += 2 if len(data) < 255 else 4
+            for index, octet in enumerate(data):
+                while offset + index in skip_bytes:
+                    offset += 1
+                tag_memory[offset+index] = octet
+            offset = offset + index + 1
+            while offset in skip_bytes:
+                offset += 1
+            if offset < tag_memory[14] * 8 + 16:
+                tag_memory[offset] = 0xFE
+            tag_memory.synchronize()
+
+            # Write the ndef message tlv length.
+            offset = self._ndef_tlv_offset
+            if len(data) < 255:
+                tag_memory[offset+1] = len(data)
+            else:
+                tag_memory[offset+1] = 0xFF
+                tag_memory[offset+2:offset+4] = pack(">H", len(data))
+            tag_memory.synchronize()
+
+    #
+    # Type2Tag methods and attributes
+    #
+    def __init__(self, clf, target):
+        super(Type2Tag, self).__init__(clf, target)
+        self._nfcid = bytearray(target.sdd_res)
+        self._current_sector = 0
+
+    def dump(self):
+        """Returns the tag memory pages as a list of formatted strings.
+
+        :meth:`dump` iterates over all tag memory pages (4 bytes
+        each) from page zero until an error response is received and
+        produces a list of strings that is intended for line by line
+        printing. Note that multiple consecutive memory pages of
+        identical content may be reduced to fewer lines of output, so
+        the number of lines returned does not necessarily correspond
+        to the number of memory pages.
+
+        """
+        return self._dump(stop=None)
+
+    def _dump(self, stop=None):
+        lines = list()
+        header = ("UID0-UID2, BCC0", "UID3-UID6",
+                  "BCC1, INT, LOCK0-LOCK1", "OTP0-OTP3")
+
+        for i, info in enumerate(header):
+            try:
+                data = self.read(i)[0:4]
+            except Type2TagCommandError:
+                data = [None, None, None, None]
+            lines.append(pagedump(i, data, info))
+
+        this_data = last_data = None
+        same_data = 0
+
+        def dump_same_data(same_data, last_data, this_data, page):
+            if same_data > 1:
+                lines.append(pagedump(None, this_data))
+            if same_data > 0:
+                lines.append(pagedump(page, this_data))
+
+        for i in range(4, stop if stop is not None else 0x40000):
+            try:
+                self.sector_select(i >> 8)
+                this_data = self.read(i)[0:4]
+            except Type2TagCommandError:
+                dump_same_data(same_data, last_data, this_data, i-1)
+                if stop is not None:
+                    this_data = last_data = [None, None, None, None]
+                    lines.append(pagedump(i, this_data))
+                    dump_same_data(stop-i-1, this_data, this_data, stop-1)
+                break
+
+            if this_data == last_data:
+                same_data += 1
+            else:
+                dump_same_data(same_data, last_data, last_data, i-1)
+                lines.append(pagedump(i, this_data))
+                last_data = this_data
+                same_data = 0
+        else:
+            dump_same_data(same_data, last_data, this_data, i)
+
+        return lines
+
+    def _is_present(self):
+        # Verify that the tag is still present. This is implemented as
+        # reading page 0-3 (from whatever sector is currently active).
+        try:
+            data = self.transceive(b"\x30\x00")
+        except Type2TagCommandError as error:
+            if error.errno != TIMEOUT_ERROR:
+                log.warning("unexpected error in presence check: %s" % error)
+            return False
+        else:
+            return bool(data and len(data) == 16)
+
+    def format(self, version=None, wipe=None):
+        """Erase the NDEF message on a Type 2 Tag.
+
+        The :meth:`format` method will reset the length of the NDEF
+        message on a type 2 tag to zero, thus the tag will appear to
+        be empty. Additionally, if the *wipe* argument is set to some
+        integer then :meth:`format` will overwrite all user date that
+        follows the NDEF message TLV with that integer (mod 256). If
+        an NDEF message TLV is not present it will be created with a
+        length of zero.
+
+        Despite it's name, the :meth:`format` method can not format a
+        blank tag to make it NDEF compatible. This is because the user
+        data are of a type 2 tag can not be safely determined, also
+        reading all memory pages until an error response yields only
+        the total memory size which includes an undetermined number of
+        special pages at the end of memory.
+
+        It is also not possible to change the NDEF mapping version,
+        located in a one-time-programmable area of the tag memory.
+
+        """
+        return super(Type2Tag, self).format(version, wipe)
+
+    def _format(self, version, wipe):
+        if self.ndef and self.ndef.is_writeable:
+            memory = self.ndef._tag_memory
+            offset = self.ndef._ndef_tlv_offset
+            memory[offset+1:offset+3] = b"\x00\xFE"
+            if wipe is not None:
+                memory_size = memory[14] * 8 + 16
+                skip_bytes = self.ndef._skip_bytes
+                for offset in range(offset + 3, memory_size):
+                    if offset not in skip_bytes:
+                        memory[offset] = wipe & 0xFF
+            memory.synchronize()
+            return True
+        return False
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """Protect the tag against write access, i.e. make it read-only.
+
+        :meth:`Type2Tag.protect` switches an NFC Forum Type 2 Tag to
+        read-only state by setting all lock bits to 1. This operation
+        can not be reversed. If the tag is not an NFC Forum Tag,
+        i.e. it is not formatted with an NDEF Capability Container,
+        the :meth:`protect` method simply returns :const:`False`.
+
+        A generic Type 2 Tag can not be protected with a password. If
+        the *password* argument is provided, the :meth:`protect`
+        method does nothing else than return :const:`False`. The
+        *read_protect* and *protect_from* arguments are safely
+        ignored.
+
+        """
+        return super(Type2Tag, self).protect(
+            password, read_protect, protect_from)
+
+    def _protect(self, password, read_protect, protect_from):
+        if password is not None:
+            log.debug("this tag can not be protected with password")
+            return False
+
+        if self.ndef is None:
+            log.debug("can not protect a non-ndef tag")
+            return False
+
+        # Set the ndef capability container write flag. We must
+        # synchronize to have this written before lock bits are set.
+        tag_memory = self.ndef._tag_memory
+        tag_memory[15] |= 0x0F
+        tag_memory.synchronize()
+
+        # Set the static lock bits.
+        tag_memory[10] = 0xFF
+        tag_memory[11] = 0xFF
+
+        # Search for all lock control tlv and store the first lock
+        # byte address and the number of lock bits in lock_control.
+        offset = 16
+        lock_control = []
+        data_area_size = tag_memory[14] * 8
+        while offset < data_area_size + 16:  # pragma: no branch
+            tlv_t, tlv_l, tlv_v = read_tlv(tag_memory, offset, set())
+            log.debug("tlv type {0} at offset {1}".format(tlv_t, offset))
+            if tlv_t in (0x03, 0xFE, None):
+                break
+            if tlv_t == 0x01:
+                log.debug("lock control tlv %s", hexlify(tlv_v).decode())
+                page_addr = tlv_v[0] >> 4
+                byte_offs = tlv_v[0] & 0x0F
+                page_size = 2 ** (tlv_v[2] & 0x0F)  # BytesPerPage
+                lock_byte_addr = page_addr * page_size + byte_offs
+                lock_bits_size = tlv_v[1] if tlv_v[1] > 0 else 256
+                lock_control.append((lock_byte_addr, lock_bits_size))
+            offset += tlv_l + 1 + (1 if tlv_l < 255 else 3)
+
+        # If the tag has a dynamic memory layout and we did not find
+        # any lock control tlv, then add default dynamic lock bits.
+        if tag_memory[14] > 6 and len(lock_control) == 0:
+            # use default dynamic lock bits layout
+            data_area_size = tag_memory[14] * 8
+            lock_byte_addr = 16 + data_area_size
+            lock_bits_size = (data_area_size - 48 + 7)//8
+            lock_control.append((lock_byte_addr, lock_bits_size))
+
+        # For any lock control entry set the referenced lock bytes to
+        # zero and then set the lock bits to one.
+        log.debug("processing lock byte list {0}".format(lock_control))
+        for lock_byte_addr, lock_bits_size in lock_control:
+            log.debug("{0} lock bits at 0x{1:02x}".format(
+                lock_bits_size, lock_byte_addr))
+            lock_byte_size = (lock_bits_size + 7) // 8
+            for i in range(lock_byte_size):
+                tag_memory[lock_byte_addr+i] = 0
+            for i in range(lock_bits_size):
+                tag_memory[lock_byte_addr+(i >> 3)] |= 1 << (i & 7)
+
+        # Synchronize to write all lock bits to the tag.
+        tag_memory.synchronize()
+        return True
+
+    def read(self, page):
+        """Send a READ command to retrieve data from the tag.
+
+        The *page* argument specifies the offset in multiples of 4
+        bytes (i.e. page number 1 will return bytes 4 to 19). The data
+        returned is a byte array of length 16 or None if the block is
+        outside the readable memory range.
+
+        Command execution errors raise :exc:`Type2TagCommandError`.
+
+        """
+        log.debug("read pages {0} to {1}".format(page, page+3))
+
+        data = self.transceive(bytearray([0x30, page % 256]), timeout=0.005)
+
+        if len(data) == 1 and data[0] & 0xFA == 0x00:
+            log.debug("received nak response")
+            self.target.sel_req = self.target.sdd_res[:]
+            self._target = self.clf.sense(self.target)
+            raise Type2TagCommandError(
+                INVALID_PAGE_ERROR if self.target else src.lib.nfc.tag.RECEIVE_ERROR)
+
+        if len(data) != 16:
+            log.debug("invalid response %s", hexlify(data).decode())
+            raise Type2TagCommandError(INVALID_RESPONSE_ERROR)
+
+        return data
+
+    def write(self, page, data):
+        """Send a WRITE command to store data on the tag.
+
+        The *page* argument specifies the offset in multiples of 4
+        bytes. The *data* argument must be a string or bytearray of
+        length 4.
+
+        Command execution errors raise :exc:`Type2TagCommandError`.
+
+        """
+        if len(data) != 4:
+            raise ValueError("data must be a four byte string or array")
+
+        log.debug("write %s to page %s", hexlify(data).decode(), page)
+        rsp = self.transceive(bytearray([0xA2, page % 256]) + data)
+
+        if len(rsp) != 1:
+            log.debug("invalid response %s", hexlify(data).decode())
+            raise Type2TagCommandError(INVALID_RESPONSE_ERROR)
+
+        if rsp[0] != 0x0A:  # NAK
+            log.debug("invalid page, received nak")
+            raise Type2TagCommandError(INVALID_PAGE_ERROR)
+
+        return True
+
+    def sector_select(self, sector):
+        """Send a SECTOR_SELECT command to switch the 1K address sector.
+
+        The command is only send to the tag if the *sector* number is
+        different from the currently selected sector number (set to 0
+        when the tag instance is created). If the command was
+        successful, the currently selected sector number is updated
+        and further :meth:`read` and :meth:`write` commands will be
+        relative to that sector.
+
+        Command execution errors raise :exc:`Type2TagCommandError`.
+
+        """
+        if sector != self._current_sector:
+            log.debug("select sector {0} (pages {1} to {2})".format(
+                sector, sector << 10, ((sector+1) << 8) - 1))
+
+            sector_select_1 = b'\xC2\xFF'
+            sector_select_2 = pack('Bxxx', sector)
+
+            rsp = self.transceive(sector_select_1)
+            if len(rsp) == 1 and rsp[0] == 0x0A:
+                try:
+                    # command is passively ack'd, i.e. there's no response
+                    # and we must make sure there's no retries attempted
+                    self.transceive(sector_select_2, timeout=0.001, retries=0)
+                except Type2TagCommandError as error:
+                    assert int(error) == TIMEOUT_ERROR  # passive ack
+                else:
+                    log.debug("sector {0} does not exist".format(sector))
+                    raise Type2TagCommandError(INVALID_SECTOR_ERROR)
+            else:
+                log.debug("sector select is not supported for this tag")
+                raise Type2TagCommandError(INVALID_SECTOR_ERROR)
+
+            log.debug("sector {0} is now selected".format(sector))
+            self._current_sector = sector
+        return self._current_sector
+
+    def transceive(self, data, timeout=0.1, retries=2):
+        """Send a Type 2 Tag command and receive the response.
+
+        :meth:`transceive` is a type 2 tag specific wrapper around the
+        :meth:`nfc.ContactlessFrontend.exchange` method. It can be
+        used to send custom commands as a sequence of *data* bytes to
+        the tag and receive the response data bytes. If *timeout*
+        seconds pass without a response, the operation is aborted and
+        :exc:`~nfc.tag.TagCommandError` raised with the TIMEOUT_ERROR
+        error code.
+
+        Command execution errors raise :exc:`Type2TagCommandError`.
+
+        """
+        log.debug(">> {0} ({1:f}s)".format(hexlify(data).decode(), timeout))
+
+        if not self.target:
+            # Sometimes we have to (re)sense the target during
+            # communication. If that failed (tag gone) then any
+            # further attempt to transceive() is the same as
+            # "unrecoverable timeout error".
+            raise Type2TagCommandError(src.lib.nfc.tag.TIMEOUT_ERROR)
+
+        started = time.time()
+        error = None
+        for retry in range(1 + retries):
+            try:
+                data = self.clf.exchange(data, timeout)
+                break
+            except src.lib.nfc.clf.CommunicationError as e:
+                error = e
+                reason = error.__class__.__name__
+                log.debug("%s after %d retries" % (reason, retry))
+        else:
+            if type(error) is src.lib.nfc.clf.TimeoutError:
+                raise Type2TagCommandError(src.lib.nfc.tag.TIMEOUT_ERROR)
+            if type(error) is src.lib.nfc.clf.TransmissionError:
+                raise Type2TagCommandError(src.lib.nfc.tag.RECEIVE_ERROR)
+            if type(error) is src.lib.nfc.clf.ProtocolError:
+                raise Type2TagCommandError(src.lib.nfc.tag.PROTOCOL_ERROR)
+            raise RuntimeError("unexpected " + repr(error))
+
+        elapsed = time.time() - started
+        log.debug("<< {0} ({1:f}s)".format(hexlify(data).decode(), elapsed))
+        return data
+
+
+class Type2TagMemoryReader(object):
+    """The memory reader provides a convenient way to read and write
+    :class:`Type2Tag` memory. Once instantiated with a proper type
+    2 *tag* object the tag memory can then be accessed as a linear
+    sequence of bytes, without any considerations of sector or
+    page boundaries. Modified bytes can be written to tag memory
+    with :meth:`synchronize`. ::
+
+        clf = nfc.ContactlessFrontend(...)
+        tag = clf.connect(rdwr={'on-connect': None})
+        if isinstance(tag, nfc.tag.tt2.Type2Tag):
+            tag_memory = nfc.tag.tt2.Type2TagMemoryReader(tag)
+            tag_memory[16:19] = [0x03, 0x00, 0xFE]
+            tag_memory.synchronize()
+
+    """
+    def __init__(self, tag):
+        assert isinstance(tag, Type2Tag)
+        self._data_from_tag = bytearray()
+        self._data_in_cache = bytearray()
+        self._tag = tag
+
+    def __len__(self):
+        return len(self._data_from_tag)
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            start, stop, step = key.indices(0x100000)
+            if stop > len(self):
+                self._read_from_tag(stop)
+        elif key >= len(self):
+            self._read_from_tag(stop=key+1)
+        return self._data_in_cache[key]
+
+    def __setitem__(self, key, value):
+        self.__getitem__(key)
+        if isinstance(key, slice):
+            if len(value) != len(range(*key.indices(0x100000))):
+                msg = "{cls} requires item assignment of identical length"
+                raise ValueError(msg.format(cls=self.__class__.__name__))
+        self._data_in_cache[key] = value
+        del self._data_in_cache[len(self):]
+
+    def __delitem__(self, key):
+        msg = "{cls} object does not support item deletion"
+        raise TypeError(msg.format(cls=self.__class__.__name__))
+
+    def _read_from_tag(self, stop):
+        index = (len(self) >> 4) << 4
+        while index < stop:
+            self._tag.sector_select(index >> 10)
+            data = self._tag.read(index >> 2)
+            self._data_from_tag[index:] = data
+            self._data_in_cache[index:] = data
+            index += 16
+
+    def _write_to_tag(self, stop):
+        index = 0
+        while index < stop:
+            data = self._data_in_cache[index:index+4]
+            if data != self._data_from_tag[index:index+4]:
+                self._tag.sector_select(index >> 10)
+                self._tag.write(index >> 2, data)
+                self._data_from_tag[index:index+4] = data
+            index += 4
+
+    def synchronize(self):
+        """Write pages that contain modified data back to tag memory."""
+        self._write_to_tag(stop=len(self))
+
+
+def activate(clf, target):
+    # Type 2 Tags go mute when they receive an unsupported command. It
+    # is then necessary to sense again and by copying sdd_res to
+    # sel_req we ensure that only the same tag will be found.
+    target.sel_req = target.sdd_res[:]
+    if target.sdd_res[0] == 0x04:  # NXP
+        import src.lib.nfc.tag.tt2_nxp
+        tag = src.lib.nfc.tag.tt2_nxp.activate(clf, target)
+        if tag is not None:
+            return tag
+        else:
+            # make sure the tag is still alive
+            target = clf.sense(target)
+    if target:
+        return Type2Tag(clf, target)

src/lib/nfc/tag/tt2_nxp.py

@@ -0,0 +1,771 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2014, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 src.lib.nfc.clf
+from . import tt2
+
+import os
+import struct
+from binascii import hexlify
+from pyDes import triple_des, CBC
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class MifareUltralight(tt2.Type2Tag):
+    """Mifare Ultralight is a simple type 2 tag with no specific
+    features. It can store up to 46 byte NDEF message data. This class
+    does not do much more than to provide the known memory size.
+
+    """
+    def __init__(self, clf, target):
+        super(MifareUltralight, self).__init__(clf, target)
+        self._product = "Mifare Ultralight (MF01CU1)"
+
+    def dump(self):
+        return super(MifareUltralight, self)._dump(stop=16)
+
+
+class MifareUltralightC(tt2.Type2Tag):
+    """Mifare Ultralight C provides more memory, to store up to 142 byte
+    NDEF message data, and can be password protected.
+
+    """
+    class NDEF(tt2.Type2Tag.NDEF):
+        def _read_capability_data(self, tag_memory):
+            base_class = super(MifareUltralightC.NDEF, self)
+            if base_class._read_capability_data(tag_memory):
+                if self.tag.is_authenticated:
+                    if not self._readable and tag_memory[15] >> 4 == 8:
+                        self._readable = True
+                    if not self._writeable and tag_memory[15] & 0xF == 8:
+                        self._writeable = bool(tag_memory[10:12] == b"\0\0")
+                return True
+            return False
+
+    def __init__(self, clf, target):
+        super(MifareUltralightC, self).__init__(clf, target)
+        self._product = "Mifare Ultralight C (MF01CU2)"
+
+    def dump(self):
+        lines = super(MifareUltralightC, self)._dump(stop=40)
+
+        footer = dict(zip(range(40, 44), (
+            "LOCK2-LOCK3", "CTR0-CTR1", "AUTH0", "AUTH1")))
+
+        for i in sorted(footer.keys()):
+            try:
+                data = self.read(i)[0:4]
+            except tt2.Type2TagCommandError:
+                data = [None, None, None, None]
+            lines.append(tt2.pagedump(i, data, footer[i]))
+
+        return lines
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """Protect a Mifare Ultralight C Tag.
+
+        A Mifare Ultrlight C Tag can be provisioned with a custom
+        password (or the default manufacturer key if the password is
+        an empty string or bytearray).
+
+        A non-empty *password* must provide at least 128 bit key
+        material, in other words it must be a string or bytearray of
+        length 16 or more.
+
+        If *password* is not None, the first protected memory page can
+        be specified with the *protect_from* integer argument. A
+        memory page is 4 byte and the total number of pages is 48. A
+        *protect_from* argument of 48 effectively disables memory
+        protection. A *protect_from* argument of 3 protects all user
+        data pages including the bitwise one-time-programmable page
+        3. Any value less than 3 or more than 48 is accepted but to
+        the same effect as if 3 or 48 were specified. If effective
+        protection starts at page 3 and the tag is formatted for NDEF,
+        the :meth:`protect` method does also modify the NDEF
+        read/write capability byte.
+
+        If *password* is not None and *read_protect* is True then the
+        tag memory content will also be protected against read access,
+        i.e. successful authentication will be required to read
+        protected pages.
+
+        The :meth:`protect` method verifies a password change by
+        authenticating with the new *password* after all modifications
+        were made and returns the result of :meth:`authenticate`.
+
+        .. warning:: If protect is called without a password, the
+            default Type 2 Tag protection method will set the lock
+            bits to readonly. This process is not reversible.
+
+        """
+        args = (password, read_protect, protect_from)
+        return super(MifareUltralightC, self).protect(*args)
+
+    def _protect(self, password, read_protect, protect_from):
+        if password is None:
+            return self._protect_with_lockbits()
+        else:
+            args = (password, read_protect, protect_from)
+            return self._protect_with_password(*args)
+
+    def _protect_with_lockbits(self):
+        try:
+            ndef_cc = self.read(3)[0:4]
+            if ndef_cc[0] == 0xE1 and ndef_cc[1] >> 4 == 1:
+                ndef_cc[3] = 0x0F
+                self.write(3, ndef_cc)
+            self.write(2, b"\x00\x00\xFF\xFF")
+            self.write(40, b"\xFF\xFF\x00\x00")
+            return True
+        except tt2.Type2TagCommandError:
+            return False
+
+    def _protect_with_password(self, password, read_protect, protect_from):
+        if password and len(password) < 16:
+            raise ValueError("password must be at least 16 byte")
+
+        # The first 16 password character bytes are taken as key
+        # unless the password is empty. If it's empty we use the
+        # factory default password.
+        key = password[0:16] if password != b"" else b"IEMKAERB!NACUOYF"
+        log.debug("protect with key %s", hexlify(key).decode())
+
+        # split the key and reverse
+        key1, key2 = key[7::-1], key[15:7:-1]
+        self.write(44, key1[0:4])
+        self.write(45, key1[4:8])
+        self.write(46, key2[0:4])
+        self.write(47, key2[4:8])
+
+        # protect from memory page
+        self.write(42, bytearray([max(3, min(protect_from, 0x30))]) +
+                   b"\0\0\0")
+
+        # set read protection flag
+        self.write(43, b"\0\0\0\0" if read_protect else b"\x01\0\0\0")
+
+        # Set NDEF read/write permissions if protection starts at page
+        # 3 and the tag is formatted for NDEF. We set the read/write
+        # permission flags to 8, thus indicating proprietary access.
+        if protect_from <= 3:
+            ndef_cc = self.read(3)[0:4]
+            if ndef_cc[0] == 0xE1 and ndef_cc[1] & 0xF0 == 0x10:
+                ndef_cc[3] |= (0x88 if read_protect else 0x08)
+                self.write(3, ndef_cc)
+
+        # Reactivate the tag to have the key effective and
+        # authenticate with the same key
+        self._target = self.clf.sense(self.target)
+        return self.authenticate(key) if self.target else False
+
+    def authenticate(self, password):
+        """Authenticate with a Mifare Ultralight C Tag.
+
+        :meth:`autenticate` executes the Mifare Ultralight C mutual
+        authentication protocol to verify that the *password* argument
+        matches the key that is stored in the card. A new card key can
+        be set with :meth:`protect`.
+
+        The *password* argument must be a string with either 0 or at
+        least 16 bytes. A zero length password string indicates that
+        the factory default card key be used. From a password with 16
+        or more bytes the first 16 byte are taken as card key,
+        remaining bytes are ignored. A password length between 1 and
+        15 generates a ValueError exception.
+
+        The authentication result is True if the password was
+        confirmed and False if not.
+
+        """
+        return super(MifareUltralightC, self).authenticate(password)
+
+    def _authenticate(self, password):
+        # The first 16 password character bytes are taken as key
+        # unless the password is empty. If it's empty we use the
+        # factory default password.
+        key = password[0:16] if password != b"" else b"IEMKAERB!NACUOYF"
+
+        if len(key) != 16:
+            raise ValueError("password must be at least 16 byte")
+
+        log.debug("authenticate with key %s", hexlify(key).decode())
+
+        rsp = self.transceive(b"\x1A\x00")
+        m1 = bytes(rsp[1:9])
+        iv = b"\x00\x00\x00\x00\x00\x00\x00\x00"
+        rb = triple_des(key, CBC, iv).decrypt(m1)
+
+        log.debug("received challenge")
+        log.debug("iv = %s", hexlify(iv).decode())
+        log.debug("m1 = %s", hexlify(m1).decode())
+        log.debug("rb = %s", hexlify(rb).decode())
+
+        ra = os.urandom(8)
+        iv = bytes(rsp[1:9])
+
+        m2 = triple_des(key, CBC, iv).encrypt(ra + rb[1:8] + (
+            struct.pack("B", rb[0]) if isinstance(rb[0], int) else rb[0]))
+
+        log.debug("sending response")
+        log.debug("ra = %s", hexlify(ra).decode())
+        log.debug("iv = %s", hexlify(iv).decode())
+        log.debug("m2 = %s", hexlify(m2).decode())
+        try:
+            rsp = self.transceive(b"\xAF" + m2)
+        except tt2.Type2TagCommandError:
+            return False
+
+        m3 = bytes(rsp[1:9])
+        iv = m2[8:16]
+        log.debug("received confirmation")
+        log.debug("iv = %s", hexlify(iv).decode())
+        log.debug("m3 = %s", hexlify(m3).decode())
+
+        return triple_des(key, CBC, iv).decrypt(m3) == ra[1:9] \
+            + (struct.pack("B", ra[0]) if isinstance(ra[0], int) else ra[0])
+
+
+class NTAG203(tt2.Type2Tag):
+    """The NTAG203 is a plain memory Tag with 144 bytes user data memory
+    plus a 16-bit one-way counter. It does not have any security
+    features beyond the standard lock bit mechanism that permanently
+    disables write access.
+
+    """
+    def __init__(self, clf, target):
+        super(NTAG203, self).__init__(clf, target)
+        self._product = "NXP NTAG203"
+
+    def dump(self):
+        lines = super(NTAG203, self)._dump(40)
+
+        footer = dict(zip(range(40, 42), ("LOCK2-LOCK3", "CNTR0-CNTR1")))
+
+        for i in sorted(footer.keys()):
+            try:
+                data = self.read(i)[0:4]
+            except tt2.Type2TagCommandError:
+                data = [None, None, None, None]
+            lines.append(tt2.pagedump(i, data, footer[i]))
+
+        return lines
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """Set lock bits to disable future memory modifications.
+
+        If *password* is None, all memory pages except the 16-bit
+        counter in page 41 are protected by setting the relevant lock
+        bits (note that lock bits can not be reset). If valid NDEF
+        management data is found in page 4, protect() also sets the
+        NDEF write flag to read-only.
+
+        The NTAG203 can not be password protected. If a *password*
+        argument is provided, the protect() method always returns
+        False.
+
+        """
+        return super(NTAG203, self).protect(
+            password, read_protect, protect_from)
+
+    def _protect(self, password, read_protect, protect_from):
+        if password is None:
+            try:
+                ndef_cc = self.read(3)[0:4]
+                if ndef_cc[0] == 0xE1 and ndef_cc[1] >> 4 == 1:
+                    ndef_cc[3] = 0x0F
+                    self.write(3, ndef_cc)
+                self.write(2, b"\x00\x00\xFF\xFF")
+                self.write(40, b"\xFF\x01\x00\x00")
+                return True
+            except tt2.Type2TagCommandError:
+                pass
+        return False
+
+    def _format(self, version, wipe):
+        if self.ndef is None:
+            log.debug("no management data, writing factory defaults")
+            self.write(4, b'\x01\x03\xA0\x10')
+            self.write(5, b'\x44\x03\x00\xFE')
+        return super(NTAG203, self)._format(version, wipe)
+
+
+class NTAG21x(tt2.Type2Tag):
+    """Base class for the NTAG21x family (210/212/213/215/216). The
+    methods and attributes documented here are supported for all
+    NTAG21x products.
+
+    All NTAG21x products support a simple password protection scheme
+    that can be configured to restrict write as well as read access to
+    memory starting from a selected page address. A factory programmed
+    ECC signature allows to verify the tag unique identifier.
+
+    """
+    class NDEF(tt2.Type2Tag.NDEF):
+        def _read_capability_data(self, tag_memory):
+            if super(NTAG21x.NDEF, self)._read_capability_data(tag_memory):
+                if self.tag.is_authenticated:
+                    if not self._readable and tag_memory[15] >> 4 == 8:
+                        self._readable = True
+                    if not self._writeable and tag_memory[15] & 0xF == 8:
+                        self._writeable = bool(tag_memory[10:12] == b"\0\0")
+                return True
+            return False
+
+    @property
+    def signature(self):
+        """The 32-byte ECC tag signature programmed at chip production. The
+        signature is provided as a string and can only be read.
+
+        The signature attribute is always loaded from the tag when it
+        is accessed, i.e. it is not cached. If communication with the
+        tag fails for some reason the signature attribute is set to a
+        32-byte string of all zeros.
+
+        """
+        log.debug("read tag signature")
+        try:
+            return bytes(self.transceive(b"\x3C\x00"))
+        except tt2.Type2TagCommandError:
+            return 32 * b"\0"
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """Set password protection or permanent lock bits.
+
+        If the *password* argument is None, all memory pages will be
+        protected by setting the relevant lock bits (note that lock
+        bits can not be reset). If valid NDEF management data is
+        found, protect() also sets the NDEF write flag to read-only.
+
+        All Tags of the NTAG21x family can alternatively be protected
+        by password. If a *password* argument is provided, the
+        protect() method writes the first 4 byte of the *password*
+        string into the Tag's password (PWD) memory bytes and the
+        following 2 byte of the *password* string into the password
+        acknowledge (PACK) memory bytes. Factory default values are
+        used if the *password* argument is an empty string. Lock bits
+        are not set for password protection.
+
+        The *read_protect* and *protect_from* arguments are only
+        evaluated if *password* is not None. If *read_protect* is
+        True, the memory protection bit (PROT) is set to require
+        password verification also for reading of protected memory
+        pages. The value of *protect_from* determines the first
+        password protected memory page (one page is 4 byte) with the
+        exception that the smallest set value is page 3 even if
+        *protect_from* is smaller.
+
+        """
+        args = (password, read_protect, protect_from)
+        return super(NTAG21x, self).protect(*args)
+
+    def _protect(self, password, read_protect, protect_from):
+        if password is None:
+            return self._protect_with_lockbits()
+        else:
+            args = (password, read_protect, protect_from)
+            return self._protect_with_password(*args)
+
+    def _protect_with_lockbits(self):
+        try:
+            ndef_cc = self.read(3)[0:4]
+            if ndef_cc[0] == 0xE1 and ndef_cc[1] >> 4 == 1:
+                ndef_cc[3] = 0x0F
+                self.write(3, ndef_cc)
+            self.write(2, b"\x00\x00\xFF\xFF")
+            if self._cfgpage > 16:
+                self.write(self._cfgpage - 1, b"\xFF\xFF\xFF\x00")
+            cfgdata = self.read(self._cfgpage)
+            if cfgdata[4] & 0x40 == 0:
+                cfgdata[4] |= 0x40  # set CFGLCK bit
+                self.write(self._cfgpage + 1, cfgdata[4:8])
+            return True
+        except tt2.Type2TagCommandError:
+            return False
+
+    def _protect_with_password(self, password, read_protect, protect_from):
+        if password and len(password) < 6:
+            raise ValueError("password must be at least 6 bytes")
+
+        key = password[0:6] if password != b"" else b"\xFF\xFF\xFF\xFF\0\0"
+        log.debug("protect with key %s", hexlify(key).decode())
+
+        # read CFG0, CFG1, PWD and PACK
+        cfg = self.read(self._cfgpage)
+
+        # set password and acknowledge
+        cfg[8:14] = key
+
+        # start protection from page
+        cfg[3] = max(3, min(protect_from, 255))
+
+        # set read protection bit
+        cfg[4] = cfg[4] | 0x80 if read_protect else cfg[4] & 0x7F
+
+        # write configuration to tag
+        for i in range(4):
+            self.write(self._cfgpage + i, cfg[i*4:(i+1)*4])
+
+        # Set NDEF read/write permissions if protection starts at page
+        # 3 and the tag is formatted for NDEF. We set the read/write
+        # permission flags to 8, thus indicating proprietary access.
+        if protect_from <= 3:
+            ndef_cc = self.read(3)[0:4]
+            if ndef_cc[0] == 0xE1 and ndef_cc[1] & 0xF0 == 0x10:
+                ndef_cc[3] |= (0x88 if read_protect else 0x08)
+                self.write(3, ndef_cc)
+
+        # Reactivate the tag to have the key effective and
+        # authenticate with the same key
+        self._target = self.clf.sense(self.target)
+        return self.authenticate(key) if self.target else False
+
+    def authenticate(self, password):
+        """Authenticate with password to access protected memory.
+
+        An NTAG21x implements a simple password protection scheme. The
+        reader proofs possession of a share secret by sending a 4-byte
+        password and the tag proofs possession of a shared secret by
+        returning a 2-byte password acknowledge. Because password and
+        password acknowledge are transmitted in plain text special
+        considerations should be given to under which conditions
+        authentication is performed. If, for example, an attacker is
+        able to mount a relay attack both secret values are easily
+        lost.
+
+        The *password* argument must be a string of length zero or at
+        least 6 byte characters. If the *password* length is zero,
+        authentication is performed with factory default values. If
+        the *password* contains at least 6 bytes, the first 4 byte are
+        send to the tag as the password secret and the following 2
+        byte are compared against the password acknowledge that is
+        received from the tag.
+
+        The authentication result is True if the password was
+        confirmed and False if not.
+
+        """
+        return super(NTAG21x, self).authenticate(password)
+
+    def _authenticate(self, password):
+        if password and len(password) < 6:
+            raise ValueError("password must be at least 6 bytes")
+
+        key = password[0:6] if password != b"" else b"\xFF\xFF\xFF\xFF\0\0"
+        log.debug("authenticate with key %s", hexlify(key).decode())
+
+        try:
+            rsp = self.transceive(b"\x1B" + key[0:4])
+            return rsp == key[4:6]
+        except tt2.Type2TagCommandError:
+            return False
+
+    def _dump(self, stop, footer):
+        lines = super(NTAG21x, self)._dump(stop)
+        for i in sorted(footer.keys()):
+            try:
+                data = self.read(i)[0:4]
+            except tt2.Type2TagCommandError:
+                data = [None, None, None, None]
+            lines.append(tt2.pagedump(i, data, footer[i]))
+        return lines
+
+
+class NTAG210(NTAG21x):
+    """The NTAG210 provides 48 bytes user data memory, password
+    protection, originality signature and a UID mirror function.
+
+    """
+    def __init__(self, clf, target):
+        super(NTAG210, self).__init__(clf, target)
+        self._product = "NXP NTAG210"
+        self._cfgpage = 16
+
+    def _format(self, version, wipe):
+        if self.ndef is None:
+            log.debug("no management data, writing factory defaults")
+            self.write(4, b'\x03\x00\xFE\x00')
+            self.write(5, b'\x00\x00\x00\x00')
+        return super(NTAG210, self)._format(version, wipe)
+
+    def dump(self):
+        footer = dict(zip(range(16, 20),
+                          ("MIRROR_BYTE, RFU, MIRROR_PAGE, AUTH0",
+                           "ACCESS", "PWD0-PWD3", "PACK0-PACK1")))
+        return super(NTAG210, self)._dump(16, footer)
+
+
+class NTAG212(NTAG21x):
+    """The NTAG212 provides 128 bytes user data memory, password
+    protection, originality signature and a UID mirror function.
+
+    """
+    def __init__(self, clf, target):
+        super(NTAG212, self).__init__(clf, target)
+        self._product = "NXP NTAG212"
+        self._cfgpage = 37
+
+    def _format(self, version, wipe):
+        if self.ndef is None:
+            log.debug("no management data, writing factory defaults")
+            self.write(4, b'\x01\x03\x90\x0A')
+            self.write(5, b'\x34\x03\x00\xFE')
+        return super(NTAG212, self)._format(version, wipe)
+
+    def dump(self):
+        text = ("LOCK2-LOCK4", "MIRROR_BYTE, RFU, MIRROR_PAGE, AUTH0",
+                "ACCESS", "PWD0-PWD3", "PACK0-PACK1")
+        footer = dict(zip(range(36, 36+len(text)), text))
+        return super(NTAG212, self)._dump(36, footer)
+
+
+class NTAG213(NTAG21x):
+    """The NTAG213 provides 144 bytes user data memory, password
+    protection, originality signature, a tag read counter and a mirror
+    function for the tag unique identifier and the read counter.
+
+    """
+    def __init__(self, clf, target):
+        super(NTAG213, self).__init__(clf, target)
+        self._product = "NXP NTAG213"
+        self._cfgpage = 41
+
+    def _format(self, version, wipe):
+        if self.ndef is None:
+            log.debug("no management data, writing factory defaults")
+            self.write(4, b'\x01\x03\xA0\x0C')
+            self.write(5, b'\x34\x03\x00\xFE')
+        return super(NTAG213, self)._format(version, wipe)
+
+    def dump(self):
+        text = ("LOCK2-LOCK4", "MIRROR, RFU, MIRROR_PAGE, AUTH0",
+                "ACCESS", "PWD0-PWD3", "PACK0-PACK1")
+        footer = dict(zip(range(40, 40+len(text)), text))
+        return super(NTAG213, self)._dump(40, footer)
+
+
+class NTAG215(NTAG21x):
+    """The NTAG215 provides 504 bytes user data memory, password
+    protection, originality signature, a tag read counter and a mirror
+    function for the tag unique identifier and the read counter.
+
+    """
+    def __init__(self, clf, target):
+        super(NTAG215, self).__init__(clf, target)
+        self._product = "NXP NTAG215"
+        self._cfgpage = 131
+
+    def _format(self, version, wipe):
+        if self.ndef is None:
+            log.debug("no management data, writing factory defaults")
+            self.write(4, b'\x03\x00\xFE\x00')
+            self.write(5, b'\x00\x00\x00\x00')
+        return super(NTAG215, self)._format(version, wipe)
+
+    def dump(self):
+        text = ("LOCK2-LOCK4", "MIRROR, RFU, MIRROR_PAGE, AUTH0",
+                "ACCESS", "PWD0-PWD3", "PACK0-PACK1")
+        footer = dict(zip(range(130, 130+len(text)), text))
+        return super(NTAG215, self)._dump(130, footer)
+
+
+class NTAG216(NTAG21x):
+    """The NTAG216 provides 888 bytes user data memory, password
+    protection, originality signature, a tag read counter and a mirror
+    function for the tag unique identifier and the read counter.
+
+    """
+    def __init__(self, clf, target):
+        super(NTAG216, self).__init__(clf, target)
+        self._product = "NXP NTAG216"
+        self._cfgpage = 227
+
+    def _format(self, version, wipe):
+        if self.ndef is None:
+            log.debug("no management data, writing factory defaults")
+            self.write(4, b'\x03\x00\xFE\x00')
+            self.write(5, b'\x00\x00\x00\x00')
+        return super(NTAG216, self)._format(version, wipe)
+
+    def dump(self):
+        text = ("LOCK2-LOCK4", "MIRROR, RFU, MIRROR_PAGE, AUTH0",
+                "ACCESS", "PWD0-PWD3", "PACK0-PACK1")
+        footer = dict(zip(range(226, 226+len(text)), text))
+        return super(NTAG216, self)._dump(226, footer)
+
+
+class MifareUltralightEV1(NTAG21x):
+    """Mifare Ultralight EV1
+
+    """
+    def __init__(self, clf, target, product):
+        super(MifareUltralightEV1, self).__init__(clf, target)
+        self._product = "Mifare Ultralight EV1 ({0})".format(product)
+
+    def _dump_ul11(self):
+        text = ("MOD, RFU, RFU, AUTH0", "ACCESS, VCTID, RFU, RFU",
+                "PWD0, PWD1, PWD2, PWD3", "PACK0, PACK1, RFU, RFU")
+        footer = dict(zip(range(16, 16+len(text)), text))
+        return super(MifareUltralightEV1, self)._dump(16, footer)
+
+    def _dump_ul21(self):
+        text = ("LOCK2, LOCK3, LOCK4, RFU",
+                "MOD, RFU, RFU, AUTH0", "ACCESS, VCTID, RFU, RFU",
+                "PWD0, PWD1, PWD2, PWD3", "PACK0, PACK1, RFU, RFU")
+        footer = dict(zip(range(36, 36+len(text)), text))
+        return super(MifareUltralightEV1, self)._dump(36, footer)
+
+
+class MF0UL11(MifareUltralightEV1):
+    def __init__(self, clf, target):
+        super(MF0UL11, self).__init__(clf, target, "MF0UL11")
+
+    def dump(self):
+        return self._dump_ul11()
+
+
+class MF0ULH11(MifareUltralightEV1):
+    def __init__(self, clf, target):
+        super(MF0ULH11, self).__init__(clf, target, "MF0ULH11")
+
+    def dump(self):
+        return self._dump_ul11()
+
+
+class MF0UL21(MifareUltralightEV1):
+    def __init__(self, clf, target):
+        super(MF0UL21, self).__init__(clf, target, "MF0UL21")
+
+    def dump(self):
+        return self._dump_ul21()
+
+
+class MF0ULH21(MifareUltralightEV1):
+    def __init__(self, clf, target):
+        super(MF0ULH21, self).__init__(clf, target, "MF0ULH21")
+
+    def dump(self):
+        return self._dump_ul21()
+
+
+class NTAGI2C(tt2.Type2Tag):
+    def _dump(self, stop):
+        s = super(NTAGI2C, self)._dump(stop)
+
+        data = self.read(stop)[0:4]
+        s.append(tt2.pagedump(stop, data, "LOCK2-LOCK4, CHK"))
+
+        data = self.read(232)
+        s.append("")
+        s.append("Configuration registers:")
+        s.append(tt2.pagedump(stop & 256 | 232, data[0:4],
+                              "NC, LD, SM, WDT0"))
+        s.append(tt2.pagedump(stop & 256 | 233, data[4:8],
+                              "WDT1, CLK, LOCK, RFU"))
+
+        self.sector_select(3)
+        data = self.read(248)
+        s.append("")
+        s.append("Session registers:")
+        s.append(tt2.pagedump(0x3F8, data[0:4], "NC, LD, SM, WDT0"))
+        s.append(tt2.pagedump(0x3F9, data[4:8], "WDT1, CLK, NS, RFU"))
+
+        self.sector_select(0)
+        return s
+
+
+class NT3H1101(NTAGI2C):
+    """NTAG I2C 1K.
+
+    """
+    def __init__(self, clf, target):
+        super(NT3H1101, self).__init__(clf, target)
+        self._product = "NTAG I2C 1K (NT3H1101)"
+
+    def dump(self):
+        return super(NT3H1101, self)._dump(226)
+
+
+class NT3H1201(NTAGI2C):
+    """NTAG I2C 2K.
+
+    """
+    def __init__(self, clf, target):
+        super(NT3H1201, self).__init__(clf, target)
+        self._product = "NTAG I2C 2K (NT3H1201)"
+
+    def dump(self):
+        return super(NT3H1201, self)._dump(480)
+
+
+VERSION_MAP = {
+    b"\x00\x04\x03\x01\x01\x00\x0B\x03": MF0UL11,
+    b"\x00\x04\x03\x02\x01\x00\x0B\x03": MF0ULH11,
+    b"\x00\x04\x03\x01\x01\x00\x0E\x03": MF0UL21,
+    b"\x00\x04\x03\x02\x01\x00\x0E\x03": MF0ULH21,
+    b"\x00\x04\x04\x01\x01\x00\x0B\x03": NTAG210,
+    b"\x00\x04\x04\x01\x01\x00\x0E\x03": NTAG212,
+    b"\x00\x04\x04\x02\x01\x00\x0F\x03": NTAG213,
+    b"\x00\x04\x04\x02\x01\x00\x11\x03": NTAG215,
+    b"\x00\x04\x04\x02\x01\x00\x13\x03": NTAG216,
+    b"\x00\x04\x04\x05\x02\x01\x13\x03": NT3H1101,
+    b"\x00\x04\x04\x05\x02\x01\x15\x03": NT3H1201,
+    # b"\x00\x04\x04\x05\x02\x02\x13\x03": NT3H2111,
+    # b"\x00\x04\x04\x05\x02\x02\x15\x03": NT3H2211,
+}
+
+
+def activate(clf, target):
+    log.debug("check if authenticate command is available")
+    try:
+        rsp = clf.exchange(b'\x1A\x00', timeout=0.01)
+        if clf.sense(target) is None:
+            return
+        if rsp.startswith(b"\xAF"):
+            return MifareUltralightC(clf, target)
+    except src.lib.nfc.clf.TimeoutError:
+        if clf.sense(target) is None:
+            return
+    except src.lib.nfc.clf.CommunicationError as error:
+        log.debug(repr(error))
+        return
+
+    log.debug("check if version command is available")
+    try:
+        rsp = bytes(clf.exchange(b'\x60', timeout=0.01))
+        if rsp in VERSION_MAP:
+            return VERSION_MAP[rsp](clf, target)
+        if rsp == b"\x00":
+            if clf.sense(target) is None:
+                return None
+            else:
+                return NTAG203(clf, target)
+        log.debug("no match for version %s", hexlify(rsp).decode().upper())
+        return
+    except src.lib.nfc.clf.TimeoutError:
+        if clf.sense(target) is None:
+            return
+    except src.lib.nfc.clf.CommunicationError as error:
+        log.debug(repr(error))
+        return
+
+    return MifareUltralight(clf, target)

src/lib/nfc/tag/tt3.py

@@ -0,0 +1,930 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2009, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 nfc.tag
+import nfc.clf
+
+import math
+import time
+import itertools
+from binascii import hexlify
+from struct import pack, unpack
+
+import logging
+log = logging.getLogger(__name__)
+
+
+RSP_LENGTH_ERROR, RSP_CODE_ERROR, TAG_IDM_ERROR, DATA_SIZE_ERROR = range(1, 5)
+
+
+class Type3TagCommandError(nfc.tag.TagCommandError):
+    errno_str = {
+        RSP_LENGTH_ERROR: "invalid response length",
+        RSP_CODE_ERROR: "invalid response code",
+        TAG_IDM_ERROR: "answer from wrong tag",
+        DATA_SIZE_ERROR: "insufficient data received",
+        # FeliCa Lite specific error codes
+        0x01A6: "invalid service code number or attribute",
+        0x01B1: "authentication required to read (first block in list)",
+        0x02B1: "authentication required to read (second block in list)",
+        0x04B1: "authentication required to read (third block in list)",
+        0x08B1: "authentication required to read (fourth block in list)",
+        0x02B2: "verification failure for write with mac operation",
+    }
+
+
+class ServiceCode:
+    """A service code provides access to a group of data blocks located on
+    the card file system. A service code is a 16-bit structure
+    composed of a 10-bit service number and a 6-bit service
+    attribute. The service attribute determines the service type and
+    whether authentication is required.
+
+    """
+    def __init__(self, number, attribute):
+        self.number = number
+        self.attribute = attribute
+
+    def __repr__(self):
+        return "ServiceCode({0}, {1})".format(self.number, self.attribute)
+
+    def __str__(self):
+        attribute_map = {
+            0b001000: "Random RW with key",
+            0b001001: "Random RW w/o key",
+            0b001010: "Random RO with key",
+            0b001011: "Random RO w/o key",
+            0b001100: "Cyclic RW with key",
+            0b001101: "Cyclic RW w/o key",
+            0b001110: "Cyclic RO with key",
+            0b001111: "Cyclic RO w/o key",
+            0b010000: "Purse Direct with key",
+            0b010001: "Purse Direct w/o key",
+            0b010010: "Purse Cashback with key",
+            0b010011: "Purse Cashback w/o key",
+            0b010100: "Purse Decrement with key",
+            0b010101: "Purse Decrement w/o key",
+            0b010110: "Purse Read Only with key",
+            0b010111: "Purse Read Only w/o key",
+        }
+        try:
+            attribute_string = attribute_map[self.attribute]
+        except KeyError:
+            attribute_string = "Type {0:06b}b".format(self.attribute)
+        return "Service Code {0:04X}h (Service {1} {2!s})".format(
+            int(self), self.number, attribute_string)
+
+    def __int__(self):
+        return self.number << 6 | self.attribute
+
+    def pack(self):
+        """Pack the service code for transmission. Returns a 2 byte string."""
+        sn, sa = self.number, self.attribute
+        return pack("<H", (sn & 0x3ff) << 6 | (sa & 0x3f))
+
+    @classmethod
+    def unpack(cls, s):
+        """Unpack and return a ServiceCode from a byte string."""
+        v = unpack("<H", s[0:2])[0]
+        return cls(v >> 6, v & 0x3f)
+
+
+class BlockCode:
+    """A block code indicates a data block within a service. A block code
+    is a 16-bit or 24-bit structure composed of a length bit (1b if
+    the block number is less than 256), a 3-bit access mode, a 4-bit
+    service list index and an 8-bit or 16-bit block number.
+
+    """
+    def __init__(self, number, access=0, service=0):
+        self.number = number
+        self.access = access
+        self.service = service
+
+    def __repr__(self):
+        return "BlockCode({0}, {1}, {2})".format(
+            self.number, self.access, self.service)
+
+    def __str__(self):
+        s = "BlockCode(number={0}, access={1:03b}, service={2})"
+        return s.format(self.number, self.access, self.service)
+
+    def __bytes__(self):
+        return str(self).encode()
+
+    def pack(self):
+        """Pack the block code for transmission. Returns a 2-3 byte string."""
+        bn, am, sx = self.number, self.access, self.service
+        return bytes(
+                bytearray([bool(bn < 256) << 7 | (am & 0x7) << 4 | (sx & 0xf)])
+                + (bytearray([bn]) if bn < 256 else pack("<H", bn)))
+
+
+class Type3Tag(nfc.tag.Tag):
+    """Implementation of the NFC Forum Type 3 Tag specification.
+
+    The NFC Forum Type 3 Tag is based on the Sony FeliCa protocol and
+    command specification. An NFC Forum compliant Type 3 Tag responds
+    to a FeliCa polling command with system code 0x12FC and was
+    configured to support service code 0x000B for NDEF data read and
+    service code 0x0009 for NDEF data write (the latter may not be
+    present if the tag is read-only) without encryption.
+
+    """
+    TYPE = "Type3Tag"
+
+    class NDEF(nfc.tag.Tag.NDEF):
+        # Type 3 Tag specific implementation of the NDEF access type
+        # class that is returned by the Tag.ndef attribute.
+
+        def _read_attribute_data(self):
+            try:
+                data = self._tag.read_from_ndef_service(0)
+            except Type3TagCommandError:
+                return None
+
+            if sum(data[0:14]) != unpack(">H", data[14:16])[0]:
+                log.debug("ndef attribute data checksum error")
+                return None
+
+            ver, nbr, nbw, nmaxb = unpack(">BBBH", data[0:5])
+            writef, rwflag = unpack(">BB", data[9:11])
+            length = unpack(">I", b"\x00" + data[11:14])[0]
+            self._capacity = nmaxb * 16
+            self._writeable = rwflag != 0 and nbw > 0
+            self._readable = writef == 0 and nbr > 0
+            attributes = {
+                'ver': ver, 'nbr': nbr, 'nbw': nbw, 'nmaxb': nmaxb,
+                'writef': writef, 'rwflag': rwflag, 'ln': length}
+            log.debug("got ndef attributes {0}".format(attributes))
+            return attributes
+
+        def _write_attribute_data(self, attributes):
+            log.debug("set ndef attributes {0}".format(attributes))
+            attribute_data = bytearray(16)
+            attribute_data[0] = attributes['ver']
+            attribute_data[1] = attributes['nbr']
+            attribute_data[2] = attributes['nbw']
+            attribute_data[3:5] = pack('>H', attributes['nmaxb'])
+            attribute_data[9] = attributes['writef']
+            attribute_data[10] = attributes['rwflag']
+            attribute_data[11:14] = pack('>I', attributes['ln'])[1:4]
+            attribute_data[14:16] = pack('>H', sum(attribute_data[0:14]))
+            self._tag.write_to_ndef_service(attribute_data, 0)
+
+        def _read_ndef_data(self):
+            if self.tag.sys != 0x12FC:
+                try:
+                    self.tag.idm, self.tag.pmm = self._tag.polling(0x12FC)
+                    self.tag.sys = 0x12FC
+                except Type3TagCommandError:
+                    return None
+
+            attributes = self._read_attribute_data()
+            if attributes is None:
+                log.debug("found no attribute data (maybe checksum error)")
+                return None
+            if attributes['ver'] >> 4 != 1:
+                log.debug("unsupported ndef mapping major version")
+                return None
+
+            last_block_number = 1 + (attributes['ln'] + 15) // 16
+            data = bytearray()
+
+            for i in range(1, last_block_number, attributes['nbr']):
+                last_block = min(i + attributes['nbr'], last_block_number)
+                block_list = range(i, last_block)
+                try:
+                    data += self.tag.read_from_ndef_service(*block_list)
+                except Type3TagCommandError:
+                    return None
+
+            data = data[0:attributes['ln']]
+            log.debug("got {0} byte ndef data {1}{2}".format(
+                    len(data),
+                    hexlify(data[0:32]).decode(),
+                    ('', '...')[len(data) > 32]))
+
+            return data
+
+        def _write_ndef_data(self, data):
+            attributes = self._read_attribute_data()
+            attributes['writef'] = 0x0F
+            self._write_attribute_data(attributes)
+
+            log.debug("set {0} byte ndef data {1}{2}".format(
+                    len(data),
+                    hexlify(data[0:32]).decode(),
+                    ('', '...')[len(data) > 32]))
+
+            last_block_number = 1 + (len(data) + 15) // 16
+            attributes['ln'] = len(data)  # because we may need to pad zeros
+            data = data + bytearray(-len(data) % 16)  # adjust to block size
+
+            for i in range(1, last_block_number, attributes['nbw']):
+                last_block = min(i + attributes['nbw'], last_block_number)
+                block_data = data[(i-1)*16:(last_block-1)*16]
+                self._tag.write_to_ndef_service(
+                    block_data, *range(i, last_block))
+
+            attributes['writef'] = 0x00
+            self._write_attribute_data(attributes)
+            return True
+
+    def __init__(self, clf, target):
+        super(Type3Tag, self).__init__(clf, target)
+        self.idm = target.sensf_res[1:9]
+        self.pmm = target.sensf_res[9:17]
+        self.sys = 0xFFFF
+        if len(target.sensf_res) > 17:
+            self.sys = unpack(">H", target.sensf_res[17:19])[0]
+        self._nfcid = bytearray(self.idm)
+
+    def __str__(self):
+        s = " PMM={pmm} SYS={sys:04X}"
+        return nfc.tag.Tag.__str__(self) + s.format(
+            pmm=hexlify(self.pmm).decode().upper(), sys=self.sys)
+
+    def _is_present(self):
+        # Check if the card still responds to the acquired system code
+        # and the returned identifier (IDm) matches. This is called
+        # from nfc.tag.Tag for the 'is_present' attribute.
+        try:
+            idm, pmm = self.polling(self.sys)
+            return idm == self.identifier
+        except Type3TagCommandError:
+            return False
+
+    def dump(self):
+        """Read all data blocks of an NFC Forum Tag.
+
+        For an NFC Forum Tag (system code 0x12FC) :meth:`dump` reads
+        all data blocks from service 0x000B (NDEF read service) and
+        returns a list of strings suitable for printing. The number of
+        strings returned does not necessarily reflect the number of
+        data blocks because a range of data blocks with equal content
+        is reduced to fewer lines of output.
+
+        """
+        if self.sys == 0x12FC:
+            ndef_read_service = ServiceCode(0, 0b01011)
+            return self.dump_service(ndef_read_service)
+        else:
+            return ["This is not an NFC Forum Tag."]
+
+    def dump_service(self, sc):
+        """Read all data blocks of a given service.
+
+        :meth:`dump_service` reads all data blocks from the service
+        with service code *sc* and returns a list of strings suitable
+        for printing. The number of strings returned does not
+        necessarily reflect the number of data blocks because a range
+        of data blocks with equal content is reduced to fewer lines of
+        output.
+
+        """
+        def lprint(fmt, data, index):
+            ispchr = lambda x: x >= 32 and x <= 126  # noqa: E731
+
+            def print_bytes(octets):
+                return ' '.join(['%02x' % x for x in octets])
+
+            def print_chars(octets):
+                return ''.join([chr(x) if ispchr(x) else '.' for x in octets])
+
+            return fmt.format(index, print_bytes(data), print_chars(data))
+
+        data_line_fmt = "{0:04X}: {1} |{2}|"
+        same_line_fmt = "{0:<4s}  {1} |{2}|"
+
+        lines = list()
+        last_data = None
+        same_data = 0
+
+        for i in itertools.count():  # pragma: no branch
+            assert i < 0x10000
+            try:
+                this_data = self.read_without_encryption([sc], [BlockCode(i)])
+            except Type3TagCommandError:
+                i = i - 1
+                break
+
+            if this_data == last_data:
+                same_data += 1
+            else:
+                if same_data > 1:
+                    lines.append(lprint(same_line_fmt, last_data, "*"))
+                lines.append(lprint(data_line_fmt, this_data, i))
+                last_data = this_data
+                same_data = 0
+
+        if same_data > 1:
+            lines.append(lprint(same_line_fmt, last_data, "*"))
+        if same_data > 0:
+            lines.append(lprint(data_line_fmt, this_data, i))
+
+        return lines
+
+    def format(self, version=None, wipe=None):
+        """Format and blank an NFC Forum Type 3 Tag.
+
+        A generic NFC Forum Type 3 Tag can be (re)formatted if it is
+        in either one of blank, initialized or readwrite state. By
+        formatting, all contents of the attribute information block is
+        overwritten with values determined. The number of user data
+        blocks is determined by reading all memory until an error
+        response. Similarily, the maximum number of data block that
+        can be read or written with a single command is determined by
+        sending successively increased read and write commands. The
+        current data length is set to zero. The NDEF mapping version
+        is set to the latest known version number (1.0), unless the
+        *version* argument is provided and it's major version number
+        corresponds to one of the known major version numbers.
+
+        By default, no data other than the attribute block is
+        modified. To overwrite user data the *wipe* argument must be
+        set to an integer value. The lower 8 bits of that value are
+        written to all data bytes that follow the attribute block.
+
+        """
+        return super(Type3Tag, self).format(version, wipe)
+
+    def _format(self, version, wipe):
+        assert version is None or type(version) is int
+        assert wipe is None or type(wipe) is int
+
+        if self.sys != 0x12FC:
+            log.warning("not an ndef tag and can not be made compatible")
+            return False
+        if version and version >> 4 != 1:
+            log.warning("Type 3 Tag NDEF mapping major version must be 1")
+            return False
+
+        try:
+            self.read_from_ndef_service(0)
+        except Type3TagCommandError:
+            log.warning("this tag does not have any usable data blocks")
+            return False
+
+        # To determine the total number of data blocks we start with
+        # the assumption that it must be between 0 and 2**16, then try
+        # reading in the middle and adjust the range depending on
+        # whether the read was successful or not. So in each round we
+        # have the smallest number that worked and the largest number
+        # that didn't, obviously the end is when that difference is 1.
+        """
+        nmaxb = [0, 0x10000]
+        while nmaxb[1] - nmaxb[0] > 1:
+            block = nmaxb[0] + (nmaxb[1] - nmaxb[0]) // 2 - 1
+            try:
+                self.read_from_ndef_service(block)
+            except Type3TagCommandError:
+                nmaxb[1] = block + 1
+            else:
+                nmaxb[0] = block + 1
+        """
+        nmaxb = [0, 0x10000]
+        while nmaxb[1] - nmaxb[0] > 1:
+            print(nmaxb)
+            block = nmaxb[0] + (nmaxb[1] - nmaxb[0]) // 2
+            try:
+                self.read_from_ndef_service(block)
+            except Type3TagCommandError:
+                nmaxb[1] = block
+            else:
+                nmaxb[0] = block
+
+        nmaxb = nmaxb[0]
+
+        # To get the number of blocks that can be read in one command
+        # we just try to read with an increasing number of blocks.
+        for nbr in range(1, 16):
+            try:
+                self.read_from_ndef_service(*(nbr*[0]))
+            except Type3TagCommandError:
+                nbr -= 1
+                break
+
+        # To get the number of blocks that can be written in one
+        # command we do essentially the same as for nbr, just that to
+        # preserve existing data we first read and then write it back.
+        data = self.read_from_ndef_service(0)
+        for nbw in range(1, 14):
+            try:
+                self.write_to_ndef_service(nbw*data, *(nbw*[0]))
+            except Type3TagCommandError:
+                nbw -= 1
+                break
+
+        # Tags with more than 4K memory require 3-byte block number
+        # format. This reduces the maximum number of blocks in write.
+        if nbw == 13 and nmaxb > 255:
+            nbw = 12
+
+        # We now have all information needed to create and write the
+        # new attribute data to block number 0.
+        attribute_data = bytearray(16)
+        attribute_data[0:5] = pack(">BBBH", version, nbr, nbw, nmaxb)
+        attribute_data[10] = 0x01 if nbw > 0 else 0x00
+        attribute_data[14:16] = pack(">H", sum(attribute_data[0:14]))
+        log.debug("set ndef attributes %s", hexlify(attribute_data).decode())
+        self.write_to_ndef_service(attribute_data, 0)
+
+        # If required, we will also overwrite the memory with the
+        # 8-bit integer provided. This could take a while.
+        if wipe is not None:
+            data = bytearray([wipe]) * 16
+            while nmaxb > 0:
+                self.write_to_ndef_service(data, nmaxb)
+                nmaxb = nmaxb - 1
+
+        return True
+
+    def polling(self, system_code=0xffff, request_code=0, time_slots=0):
+        """Aquire and identify a card.
+
+        The Polling command is used to detect the Type 3 Tags in the
+        field. It is also used for initialization and anti-collision.
+
+        The *system_code* identifies the card system to acquire. A
+        card can have multiple systems. The first system that matches
+        *system_code* will be activated. A value of 0xff for any of
+        the two bytes works as a wildcard, thus 0xffff activates the
+        very first system in the card. The card identification data
+        returned are the Manufacture ID (IDm) and Manufacture
+        Parameter (PMm).
+
+        The *request_code* tells the card whether it should return
+        additional information. The default value 0 requests no
+        additional information. Request code 1 means that the card
+        shall also return the system code, so polling for system code
+        0xffff with request code 1 can be used to identify the first
+        system on the card. Request code 2 asks for communication
+        performance data, more precisely a bitmap of possible
+        communication speeds. Not all cards provide that information.
+
+        The number of *time_slots* determines whether there's a chance
+        to receive a response if multiple Type 3 Tags are in the
+        field. For the reader the number of time slots determines the
+        amount of time to wait for a response. Any Type 3 Tag in the
+        field, i.e. powered by the field, will choose a random time
+        slot to respond. With the default *time_slots* value 0 there
+        will only be one time slot available for all responses and
+        multiple responses would produce a collision. More time slots
+        reduce the chance of collisions (but may result in an
+        application working with a tag that was just accidentially
+        close enough). Only specific values should be used for
+        *time_slots*, those are 0, 1, 3, 7, and 15. Other values may
+        produce unexpected results depending on the tag product.
+
+        :meth:`polling` returns either the tuple (IDm, PMm) or the
+        tuple (IDm, PMm, *additional information*) depending on the
+        response lengt, all as bytearrays.
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+
+        log.debug("polling for system 0x{0:04x}".format(system_code))
+        if time_slots not in (0, 1, 3, 7, 15):
+            log.debug("invalid number of time slots: {0}".format(time_slots))
+            raise ValueError("invalid number of time slots")
+        if request_code not in (0, 1, 2):
+            log.debug("invalid request code value: {0}".format(request_code))
+            raise ValueError("invalid request code for polling")
+
+        timeout = 0.003625 + time_slots * 0.001208
+        data = pack(">HBB", system_code, request_code, time_slots)
+        data = self.send_cmd_recv_rsp(0x00, data, timeout, send_idm=False)
+        if len(data) != (16 if request_code == 0 else 18):
+            log.debug("unexpected polling response length")
+            raise Type3TagCommandError(DATA_SIZE_ERROR)
+
+        return (data[0:8], data[8:16]) if len(data) == 16 else \
+            (data[0:8], data[8:16], data[16:18])
+
+    def read_without_encryption(self, service_list, block_list):
+        """Read data blocks from unencrypted services.
+
+        This method sends a Read Without Encryption command to the
+        tag. The data blocks to read are indicated by a sequence of
+        :class:`~nfc.tag.tt3.BlockCode` objects in *block_list*. Each
+        block code must reference a :class:`~nfc.tag.tt3.ServiceCode`
+        object from the iterable *service_list*. If any of the blocks
+        and services do not exist, the tag will stop processing at
+        that point and return a two byte error status. The status
+        bytes become the :attr:`~nfc.tag.TagCommandError.errno` value
+        of the :exc:`~nfc.tag.TagCommandError` exception.
+
+        As an example, the following code reads block 5 from service
+        16 (service type 'random read-write w/o key') and blocks 0 to
+        1 from service 80 (service type 'random read-only w/o key')::
+
+            sc1 = nfc.tag.tt3.ServiceCode(16, 0x09)
+            sc2 = nfc.tag.tt3.ServiceCode(80, 0x0B)
+            bc1 = nfc.tag.tt3.BlockCode(5, service=0)
+            bc2 = nfc.tag.tt3.BlockCode(0, service=1)
+            bc3 = nfc.tag.tt3.BlockCode(1, service=1)
+            try:
+                data = tag.read_without_encryption([sc1, sc2], [bc1, bc2, bc3])
+            except nfc.tag.TagCommandError as e:
+                if e.errno > 0x00FF:
+                    print("the tag returned an error status")
+                else:
+                    print("command failed with some other error")
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        a, b, e = self.pmm[5] & 7, self.pmm[5] >> 3 & 7, self.pmm[5] >> 6
+        timeout = 302.1E-6 * ((b + 1) * len(block_list) + a + 1) * 4**e
+
+        data = bytearray([
+            len(service_list)]) \
+            + b''.join([sc.pack() for sc in service_list]) \
+            + bytearray([len(block_list)]) \
+            + b''.join([bc.pack() for bc in block_list])
+
+        log.debug("read w/o encryption service/block list: {0} / {1}".format(
+            ' '.join([hexlify(sc.pack()).decode() for sc in service_list]),
+            ' '.join([hexlify(bc.pack()).decode() for bc in block_list])))
+
+        data = self.send_cmd_recv_rsp(0x06, data, timeout)
+
+        if len(data) != 1 + len(block_list) * 16:
+            log.debug("insufficient data received from tag")
+            raise Type3TagCommandError(DATA_SIZE_ERROR)
+
+        return data[1:]
+
+    def read_from_ndef_service(self, *blocks):
+        """Read block data from an NDEF compatible tag.
+
+        This is a convinience method to read block data from a tag
+        that has system code 0x12FC (NDEF). For other tags this method
+        simply returns :const:`None`. All arguments are block numbers
+        to read. To actually pass a list of block numbers requires
+        unpacking. The following example calls would have the same
+        effect of reading 32 byte data from from blocks 1 and 8.::
+
+            data = tag.read_from_ndef_service(1, 8)
+            data = tag.read_from_ndef_service(*list(1, 8))
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        if self.sys == 0x12FC:
+            sc_list = [ServiceCode(0, 0b001011)]
+            bc_list = [BlockCode(n) for n in blocks]
+            return self.read_without_encryption(sc_list, bc_list)
+
+    def write_without_encryption(self, service_list, block_list, data):
+        """Write data blocks to unencrypted services.
+
+        This method sends a Write Without Encryption command to the
+        tag. The data blocks to overwrite are indicated by a sequence
+        of :class:`~nfc.tag.tt3.BlockCode` objects in the parameter
+        *block_list*. Each block code must reference one of the
+        :class:`~nfc.tag.tt3.ServiceCode` objects in the iterable
+        *service_list*. If any of the blocks or services do not exist,
+        the tag will stop processing at that point and return a two
+        byte error status. The status bytes become the
+        :attr:`~nfc.tag.TagCommandError.errno` value of the
+        :exc:`~nfc.tag.TagCommandError` exception. The *data* to write
+        must be a byte string or array of length ``16 *
+        len(block_list)``.
+
+        As an example, the following code writes ``16 * "\\xAA"`` to
+        block 5 of service 16, ``16 * "\\xBB"`` to block 0 of service
+        80 and ``16 * "\\xCC"`` to block 1 of service 80 (all services
+        are writeable without key)::
+
+            sc1 = nfc.tag.tt3.ServiceCode(16, 0x09)
+            sc2 = nfc.tag.tt3.ServiceCode(80, 0x09)
+            bc1 = nfc.tag.tt3.BlockCode(5, service=0)
+            bc2 = nfc.tag.tt3.BlockCode(0, service=1)
+            bc3 = nfc.tag.tt3.BlockCode(1, service=1)
+            sc_list = [sc1, sc2]
+            bc_list = [bc1, bc2, bc3]
+            data = 16 * "\\xAA" + 16 * "\\xBB" + 16 * "\\xCC"
+            try:
+                data = tag.write_without_encryption(sc_list, bc_list, data)
+            except nfc.tag.TagCommandError as e:
+                if e.errno > 0x00FF:
+                    print("the tag returned an error status")
+                else:
+                    print("command failed with some other error")
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        a, b, e = self.pmm[6] & 7, self.pmm[6] >> 3 & 7, self.pmm[6] >> 6
+        timeout = 302.1E-6 * ((b + 1) * len(block_list) + a + 1) * 4**e
+
+        data = bytearray([
+            len(service_list)]) \
+            + b"".join([sc.pack() for sc in service_list]) \
+            + bytearray([len(block_list)]) \
+            + b"".join([bc.pack() for bc in block_list]) \
+            + bytearray(data)
+
+        log.debug("write w/o encryption service/block list: {0} / {1}".format(
+            ' '.join([hexlify(sc.pack()).decode() for sc in service_list]),
+            ' '.join([hexlify(bc.pack()).decode() for bc in block_list])))
+
+        self.send_cmd_recv_rsp(0x08, data, timeout)
+
+    def write_to_ndef_service(self, data, *blocks):
+        """Write block data to an NDEF compatible tag.
+
+        This is a convinience method to write block data to a tag that
+        has system code 0x12FC (NDEF). For other tags this method
+        simply does nothing. The *data* to write must be a string or
+        bytearray with length equal ``16 * len(blocks)``. All
+        parameters following *data* are interpreted as block numbers
+        to write. To actually pass a list of block numbers requires
+        unpacking. The following example calls would have the same
+        effect of writing 32 byte zeros into blocks 1 and 8.::
+
+            tag.write_to_ndef_service(32 * "\\0", 1, 8)
+            tag.write_to_ndef_service(32 * "\\0", *list(1, 8))
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        if self.sys == 0x12FC:
+            sc_list = [ServiceCode(0, 0b001001)]
+            bc_list = [BlockCode(n) for n in blocks]
+            self.write_without_encryption(sc_list, bc_list, data)
+
+    def send_cmd_recv_rsp(self, cmd_code, cmd_data, timeout,
+                          send_idm=True, check_status=True):
+        """Send a command and receive a response.
+
+        This low level method sends an arbitrary command with the
+        8-bit integer *cmd_code*, followed by the captured tag
+        identifier (IDm) if *send_idm* is :const:`True` and the byte
+        string or bytearray *cmd_data*. It then waits *timeout*
+        seconds for a response, verifies that the response is
+        correctly formatted and, if *check_status* is :const:`True`,
+        that the status flags do not indicate an error.
+
+        All errors raise a :exc:`~nfc.tag.TagCommandError`
+        exception. Errors from response status flags produce an
+        :attr:`~nfc.tag.TagCommandError.errno` that is greater than
+        255, all other errors are below 256.
+
+        """
+        idm = self.idm if send_idm else bytearray()
+        cmd = bytearray([2+len(idm)+len(cmd_data), cmd_code]) + idm + cmd_data
+        log.debug(">> {0:02x} {1:02x} {2} {3} ({4}s)".format(
+                cmd[0], cmd[1], hexlify(cmd[2:10]).decode(),
+                hexlify(cmd[10:]).decode(), timeout))
+
+        started = time.time()
+        error = None
+        for retry in range(3):
+            try:
+                rsp = self.clf.exchange(cmd, timeout)
+                break
+            except nfc.clf.CommunicationError as e:
+                error = e
+                reason = error.__class__.__name__
+                log.debug("%s after %d retries" % (reason, retry))
+        else:
+            if type(error) is nfc.clf.TimeoutError:
+                raise Type3TagCommandError(nfc.tag.TIMEOUT_ERROR)
+            if type(error) is nfc.clf.TransmissionError:
+                raise Type3TagCommandError(nfc.tag.RECEIVE_ERROR)
+            if type(error) is nfc.clf.ProtocolError:  # pragma: no branch
+                raise Type3TagCommandError(nfc.tag.PROTOCOL_ERROR)
+
+        if rsp[0] != len(rsp):
+            log.debug("incorrect response length {0:02x}".format(rsp[0]))
+            raise Type3TagCommandError(RSP_LENGTH_ERROR)
+        if rsp[1] != cmd_code + 1:
+            log.debug("incorrect response code {0:02x}".format(rsp[1]))
+            raise Type3TagCommandError(RSP_CODE_ERROR)
+        if send_idm and rsp[2:10] != self.idm:
+            log.debug("wrong tag or transaction id {}".format(
+                    hexlify(rsp[2:10]).decode()))
+            raise Type3TagCommandError(TAG_IDM_ERROR)
+        if not send_idm:
+            log.debug("<< {0:02x} {1:02x} {2}".format(
+                rsp[0], rsp[1], hexlify(rsp[2:]).decode()))
+            return rsp[2:]
+        if check_status and rsp[10] != 0:
+            log.debug("tag returned error status {}".format(
+                    hexlify(rsp[10:12]).decode()))
+            raise Type3TagCommandError(unpack(">H", rsp[10:12])[0])
+        if not check_status:
+            log.debug("<< {0:02x} {1:02x} {2} {3}".format(
+                rsp[0], rsp[1], hexlify(rsp[2:10]).decode(),
+                hexlify(rsp[10:]).decode()))
+            return rsp[10:]
+        log.debug("<< {0:02x} {1:02x} {2} {3} {4} ({elapsed:f}s)".format(
+            rsp[0], rsp[1], hexlify(rsp[2:10]).decode(),
+            hexlify(rsp[10:12]).decode(), hexlify(rsp[12:]).decode(),
+            elapsed=time.time()-started))
+        return rsp[12:]
+
+
+class Type3TagEmulation(nfc.tag.TagEmulation):
+    """Framework for Type 3 Tag emulation.
+
+    """
+    def __init__(self, clf, target):
+        self.services = dict()
+        self.target = target
+        self.cmd = bytearray([len(target.tt3_cmd)+1]) + target.tt3_cmd
+        self.idm = target.sensf_res[1:9]
+        self.pmm = target.sensf_res[9:17]
+        self.sys = target.sensf_res[17:19]
+        self.clf = clf
+
+    def __str__(self):
+        """x.__str__() <==> str(x)"""
+        return "Type3TagEmulation IDm={id} PMm={pmm} SYS={sys}".format(
+            id=hexlify(self.idm).decode(),
+            pmm=hexlify(self.pmm).decode(),
+            sys=hexlify(self.sys).decode())
+
+    def add_service(self, service_code, block_read_func, block_write_func):
+        def default_block_read(block_number, rb, re):
+            return None
+
+        def default_block_write(block_number, block_data, wb, we):
+            return False
+
+        if block_read_func is None:
+            block_read_func = default_block_read
+
+        if block_write_func is None:
+            block_write_func = default_block_write
+
+        self.services[service_code] = (block_read_func, block_write_func)
+
+    def process_command(self, cmd):
+        log.debug("cmd: %s", hexlify(cmd).decode() if cmd else str(cmd))
+        if len(cmd) != cmd[0]:
+            log.error("tt3 command length error")
+            return None
+        if tuple(cmd[0:4]) in [(6, 0, 255, 255), (6, 0) + tuple(self.sys)]:
+            log.debug("process 'polling' command")
+            rsp = self.polling(cmd[2:])
+            return bytearray([2 + len(rsp), 0x01]) + rsp
+        if cmd[2:10] == self.idm:
+            if cmd[1] == 0x04:
+                log.debug("process 'request response' command")
+                rsp = self.request_response(cmd[10:])
+                return bytearray([10 + len(rsp), 0x05]) + self.idm + rsp
+            if cmd[1] == 0x06:
+                log.debug("process 'read without encryption' command")
+                rsp = self.read_without_encryption(cmd[10:])
+                return bytearray([10 + len(rsp), 0x07]) + self.idm + rsp
+            if cmd[1] == 0x08:
+                log.debug("process 'write without encryption' command")
+                rsp = self.write_without_encryption(cmd[10:])
+                return bytearray([10 + len(rsp), 0x09]) + self.idm + rsp
+            if cmd[1] == 0x0C:
+                log.debug("process 'request system code' command")
+                rsp = self.request_system_code(cmd[10:])
+                return bytearray([10 + len(rsp), 0x0D]) + self.idm + rsp
+
+    def send_response(self, rsp, timeout):
+        log.debug("rsp: {}".format(hexlify(rsp).decode()
+                                   if rsp is not None
+                                   else 'None'))
+        return self.clf.exchange(rsp, timeout)
+
+    def polling(self, cmd_data):
+        if cmd_data[2] == 1:
+            rsp = self.idm + self.pmm + self.sys
+        else:
+            rsp = self.idm + self.pmm
+        return rsp
+
+    def request_response(self, cmd_data):
+        return bytearray([0])
+
+    def read_without_encryption(self, cmd_data):
+        service_list = cmd_data.pop(0) * [[None, None]]
+        for i in range(len(service_list)):
+            service_code = cmd_data[1] << 8 | cmd_data[0]
+            if service_code not in self.services.keys():
+                return bytearray([0xFF, 0xA1])
+            service_list[i] = [service_code, 0]
+            del cmd_data[0:2]
+
+        service_block_list = cmd_data.pop(0) * [None]
+        if len(service_block_list) > 15:
+            return bytearray([0xFF, 0xA2])
+        for i in range(len(service_block_list)):
+            try:
+                service_list_item = service_list[cmd_data[0] & 0x0F]
+                service_code = service_list_item[0]
+                service_list_item[1] += 1
+            except IndexError:
+                return bytearray([1 << (i % 8), 0xA3])
+            if cmd_data[0] >= 128:
+                block_number = cmd_data[1]
+                del cmd_data[0:2]
+            else:
+                block_number = cmd_data[2] << 8 | cmd_data[1]
+                del cmd_data[0:3]
+            service_block_list[i] = [service_code, block_number, 0]
+
+        service_block_count = dict(service_list)
+        for service_block_list_item in service_block_list:
+            service_code = service_block_list_item[0]
+            service_block_list_item[2] = service_block_count[service_code]
+
+        block_data = bytearray()
+        for i, service_block_list_item in enumerate(service_block_list):
+            service_code, block_number, block_count = service_block_list_item
+            # rb (read begin) and re (read end) mark an atomic read
+            rb = bool(block_count == service_block_count[service_code])
+            service_block_count[service_code] -= 1
+            re = bool(service_block_count[service_code] == 0)
+            read_func, write_func = self.services[service_code]
+            one_block_data = read_func(block_number, rb, re)
+            if one_block_data is None:
+                return bytearray([1 << (i % 8), 0xA2])
+            block_data.extend(one_block_data)
+
+        return bytearray([0, 0, int(math.floor(len(block_data)/16))]) \
+            + block_data
+
+    def write_without_encryption(self, cmd_data):
+        service_list = cmd_data.pop(0) * [[None, None]]
+        for i in range(len(service_list)):
+            service_code = cmd_data[1] << 8 | cmd_data[0]
+            if service_code not in self.services.keys():
+                return bytearray([255, 0xA1])
+            service_list[i] = [service_code, 0]
+            del cmd_data[0:2]
+
+        service_block_list = cmd_data.pop(0) * [None]
+        for i in range(len(service_block_list)):
+            try:
+                service_list_item = service_list[cmd_data[0] & 0x0F]
+                service_code = service_list_item[0]
+                service_list_item[1] += 1
+            except IndexError:
+                return bytearray([1 << (i % 8), 0xA3])
+            if cmd_data[0] >= 128:
+                block_number = cmd_data[1]
+                del cmd_data[0:2]
+            else:
+                block_number = cmd_data[2] << 8 | cmd_data[1]
+                del cmd_data[0:3]
+            service_block_list[i] = [service_code, block_number, 0]
+
+        service_block_count = dict(service_list)
+        for service_block_list_item in service_block_list:
+            service_code = service_block_list_item[0]
+            service_block_list_item[2] = service_block_count[service_code]
+
+        block_data = cmd_data[0:]
+        if len(block_data) % 16 != 0:
+            return bytearray([255, 0xA2])
+
+        for i, service_block_list_item in enumerate(service_block_list):
+            service_code, block_number, block_count = service_block_list_item
+            # wb (write begin) and we (write end) mark an atomic write
+            wb = bool(block_count == service_block_count[service_code])
+            service_block_count[service_code] -= 1
+            we = bool(service_block_count[service_code] == 0)
+            read_func, write_func = self.services[service_code]
+            if not write_func(block_number, block_data[i*16:(i+1)*16], wb, we):
+                return bytearray([1 << (i % 8), 0xA2])
+
+        return bytearray([0, 0])
+
+    def request_system_code(self, cmd_data):
+        return b'\x01' + self.sys
+
+
+def activate(clf, target):
+    if not target.sensf_res[1:3] == b"\x01\xFE":
+        import nfc.tag.tt3_sony
+        tag = nfc.tag.tt3_sony.activate(clf, target)
+        return tag if tag else Type3Tag(clf, target)

src/lib/nfc/tag/tt3_sony.py

@@ -0,0 +1,987 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2014, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 nfc.tag
+from . import tt3
+
+import os
+import struct
+from binascii import hexlify
+from pyDes import triple_des, CBC
+from struct import pack, unpack
+import itertools
+
+import logging
+log = logging.getLogger(__name__)
+
+
+def activate(clf, target):
+    # http://www.sony.net/Products/felica/business/tech-support/list.html
+    ic_code = target.sensf_res[10]
+    if ic_code in FelicaLite.IC_CODE_MAP.keys():
+        return FelicaLite(clf, target)
+    if ic_code in FelicaLiteS.IC_CODE_MAP.keys():
+        return FelicaLiteS(clf, target)
+    if ic_code in FelicaStandard.IC_CODE_MAP.keys():
+        return FelicaStandard(clf, target)
+    if ic_code in FelicaMobile.IC_CODE_MAP.keys():
+        return FelicaMobile(clf, target)
+    if ic_code in FelicaPlug.IC_CODE_MAP.keys():
+        return FelicaPlug(clf, target)
+    return None
+
+
+class FelicaStandard(tt3.Type3Tag):
+    """Standard FeliCa is a range of FeliCa OS based card products with a
+    flexible file system that supports multiple applications and
+    services on the same card. Services can individually be protected
+    with a card key and all communication with protected services is
+    encrypted.
+
+    """
+    IC_CODE_MAP = {
+        # IC    IC-NAME    NBR NBW
+        0x00: ("RC-S830",    8,  8),  # RC-S831/833
+        0x01: ("RC-S915",   12,  8),  # RC-S860/862/863/864/891
+        0x02: ("RC-S919",    1,  1),  # RC-S890
+        0x08: ("RC-S952",   12,  8),
+        0x09: ("RC-S953",   12,  8),
+        0x0B: ("RC-S???",    1,  1),  # new suica
+        0x0C: ("RC-S954",   12,  8),
+        0x0D: ("RC-S960",   12, 10),  # RC-S880/889
+        0x20: ("RC-S962",   12, 10),  # RC-S885/888/892/893
+        0x32: ("RC-SA00/1",  1,  1),  # AES chip
+        0x35: ("RC-SA00/2",  1,  1),
+    }
+
+    def __init__(self, clf, target):
+        super(FelicaStandard, self).__init__(clf, target)
+        self._product = "FeliCa Standard ({0})".format(
+            self.IC_CODE_MAP[self.pmm[1]][0])
+
+    def _is_present(self):
+        # Perform a presence check. Modern FeliCa cards implement the
+        # RequestResponse command, so we'll try that first. If it
+        # fails we resort the generic way that works for all type 3
+        # tags (but resets the card operating mode to zero).
+        try:
+            return self.request_response() in (0, 1, 2, 3)
+        except tt3.Type3TagCommandError:
+            return super(FelicaStandard, self)._is_present()
+
+    def dump(self):
+        # Dump the content of a FeliCa card as good as possible. This
+        # is unfortunately rather complex because we want to reflect
+        # the area structure with indentation and summarize overlapped
+        # services under a single item.
+
+        def print_system(system_code):
+            # Print system information
+            system_code_map = {
+                0x0000: "SDK Sample",
+                0x0003: "Suica",
+                0x12FC: "NDEF",
+                0x811D: "Edy",
+                0x8620: "Blackboard",
+                0xFE00: "Common Area",
+            }
+            return ["System {0:04X} ({1})".format(
+                system_code, system_code_map.get(system_code, 'unknown'))]
+
+        def print_area(area_from, area_last, depth):
+            # Prints area information with indentation.
+            return ["{indent}Area {0:04X}--{1:04X}".format(
+                area_from, area_last, indent=depth*'  ')]
+
+        def print_service(services, depth):
+            # This function processes a list of overlapped services
+            # and reads all block data if there is one service that
+            # does not require a key. First we figure out the common
+            # service type and which access modes are available.
+            if services[0] >> 2 & 0b1111 == 0b0010:
+                service_type = "Random"
+                access_types = " & ".join([(
+                    "write with key", "write w/o key",
+                    "read with key", "read w/o key")[x & 3] for x in services])
+            if services[0] >> 2 & 0b1111 == 0b0011:
+                service_type = "Cyclic"
+                access_types = " & ".join([(
+                    "write with key", "write w/o key",
+                    "read with key", "read w/o key")[x & 3] for x in services])
+            if services[0] >> 2 & 0b1110 == 0b0100:
+                service_type = "Purse"
+                access_types = " & ".join([(
+                    "direct with key", "direct w/o key",
+                    "cashback with key", "cashback w/o key",
+                    "decrement with key", "decrement w/o key",
+                    "read with key", "read w/o key")[x & 7] for x in services])
+            # Now we print one line to verbosely describe the service
+            # and list the service codes.
+            service_codes = " ".join(["0x{0:04X}".format(x) for x in services])
+            lines = [
+                "{indent}{type} Service {number}: {access} ({0})".format(
+                    service_codes, indent=depth*'  ', type=service_type,
+                    number=services[0] >> 6, access=access_types)]
+            # The final piece is to see if any of the services allows
+            # us to read block data without a key. Services w/o key
+            # have the last bit set to 1, so we generate a list of
+            # only those services and iterate over the slice from the
+            # last item to end (that's one or zero services).
+            for service in [sc for sc in services if sc & 1][-1:]:
+                sc = tt3.ServiceCode(service >> 6, service & 0b111111)
+                for line in self.dump_service(sc):
+                    lines.append(depth*'  ' + ' ' + line)
+            return lines
+
+        # Unfortunately there are some older cards with reduced
+        # command support. If request_system_code() is not supported
+        # we can only see if the current system code is NDEF and try
+        # to dup that, otherwise it is the end.
+        try:
+            card_system_codes = self.request_system_code()
+        except nfc.tag.TagCommandError:
+            if self.sys == 0x12FC:
+                return super(FelicaStandard, self).dump()
+            else:
+                return ["unable to create a memory dump"]
+
+        # A FeliCa card has one or more systems, each system has one
+        # or more areas which may be nested, and an area may have zero
+        # to many services. The outer loop iterates over all system
+        # codes that are present on the card. The inner loop iterates
+        # by index over all area and service definitions.
+        lines = []
+        for system_code in card_system_codes:
+
+            # A system must be activated first, this is what the
+            # polling() command does.
+            idm, pmm = self.polling(system_code)
+            self.idm = idm
+            self.pmm = pmm
+            self.sys = system_code
+            lines.extend(print_system(system_code))
+
+            area_stack = []
+            overlap_services = []
+
+            # Walk through the list of services by index. The first
+            # index for which there is no service returns None and
+            # terminate the loop.
+            for service_index in itertools.count():  # pragma: no branch
+                assert service_index < 0x10000
+                depth = len(area_stack)
+                area_or_service = self.search_service_code(service_index)
+                if area_or_service is None:
+                    # Went beyond the service index. Print overlap
+                    # services if any and exit loop.
+                    if len(overlap_services) > 0:
+                        lines.extend(print_service(overlap_services, depth))
+                        overlap_services = []
+                    break
+                elif len(area_or_service) == 1:
+                    # Found a service definition. Add as overlap
+                    # service if it is either the first or same type
+                    # (Random, Cyclic, Purse) as the previous one. If
+                    # it is different then print the current overlap
+                    # services and remember this for the next round.
+                    service = area_or_service[0]
+                    end_overlap_services = False
+                    if len(overlap_services) == 0:
+                        overlap_services.append(service)
+                    elif service >> 4 == overlap_services[-1] >> 4:
+                        if service >> 4 & 1:  # purse
+                            overlap_services.append(service)
+                        elif service >> 2 == overlap_services[-1] >> 2:
+                            overlap_services.append(service)
+                        else:
+                            end_overlap_services = True
+                    else:
+                        end_overlap_services = True
+                    if end_overlap_services:
+                        lines.extend(print_service(overlap_services, depth))
+                        overlap_services = [service]
+                elif len(area_or_service) == 2:
+                    # Found an area definition. Print any services
+                    # that we might so far have assembled, then
+                    # process the area information.
+                    if len(overlap_services) > 0:
+                        lines.extend(print_service(overlap_services, depth))
+                        overlap_services = []
+                    area_from, area_last = area_or_service
+                    if len(area_stack) > 0 and area_from > area_stack[-1][1]:
+                        area_stack.pop()
+                    lines.extend(print_area(area_from, area_last, depth))
+                    area_stack.append((area_from, area_last))
+
+        return lines
+
+    def request_service(self, service_list):
+        """Verify existence of a service (or area) and get the key version.
+
+        Each service (or area) to verify must be given as a
+        :class:`~nfc.tag.tt3.ServiceCode` in the iterable
+        *service_list*. The key versions are returned as a list of
+        16-bit integers, in the order requested. If a specified
+        service (or area) does not exist, the key version will be
+        0xFFFF.
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        a, b, e = self.pmm[2] & 7, self.pmm[2] >> 3 & 7, self.pmm[2] >> 6
+        timeout = 302E-6 * ((b + 1) * len(service_list) + a + 1) * 4**e
+        pack = lambda x: x.pack()  # noqa: E731
+        data = bytearray([len(service_list)]) \
+            + b''.join(map(pack, service_list))
+        data = self.send_cmd_recv_rsp(0x02, data, timeout, check_status=False)
+        if len(data) != 1 + len(service_list) * 2:
+            log.debug("insufficient data received from tag")
+            raise tt3.Type3TagCommandError(tt3.DATA_SIZE_ERROR)
+        return [unpack("<H", data[i:i+2])[0] for i in range(1, len(data), 2)]
+
+    def request_response(self):
+        """Verify that a card is still present and get its operating mode.
+
+        The Request Response command returns the current operating
+        state of the card. The operating state changes with the
+        authentication process, a card is in Mode 0 after power-up or
+        a Polling command, transitions to Mode 1 with Authentication1,
+        to Mode 2 with Authentication2, and Mode 3 with any of the
+        card issuance commands. The :meth:`request_response` method
+        returns the mode as an integer.
+
+        Command execution errors raise
+        :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        a, b, e = self.pmm[3] & 7, self.pmm[3] >> 3 & 7, self.pmm[3] >> 6
+        timeout = 302E-6 * (b + 1 + a + 1) * 4**e
+        data = self.send_cmd_recv_rsp(0x04, b'', timeout, check_status=False)
+        if len(data) != 1:
+            log.debug("insufficient data received from tag")
+            raise tt3.Type3TagCommandError(tt3.DATA_SIZE_ERROR)
+        return data[0]  # mode
+
+    def search_service_code(self, service_index):
+        """Search for a service code that corresponds to an index.
+
+        The Search Service Code command provides access to the
+        iterable list of services and areas within the activated
+        system. The *service_index* argument may be any value from 0
+        to 0xffff. As long as there is a service or area found for a
+        given *service_index*, the information returned is a tuple
+        with either one or two 16-bit integer elements. Two integers
+        are returned for an area definition, the first is the area
+        code and the second is the largest possible service index for
+        the area. One integer, the service code, is returned for a
+        service definition. The return value is :const:`None` if the
+        *service_index* was not found.
+
+        For example, to print all services and areas of the active
+        system: ::
+
+            for i in xrange(0x10000):
+                area_or_service = tag.search_service_code(i)
+                if area_or_service is None:
+                    break
+                elif len(area_or_service) == 1:
+                    sc = area_or_service[0]
+                    print(nfc.tag.tt3.ServiceCode(sc >> 6, sc & 0x3f))
+                elif len(area_or_service) == 2:
+                    area_code, area_last = area_or_service
+                    print("Area {0:04x}--{0:04x}".format(area_code, area_last))
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        log.debug("search service code index {0}".format(service_index))
+        # The maximum response time is given by the value of PMM[3].
+        # Some cards (like RC-S860 with IC RC-S915) encode a value
+        # that is too short, thus we use at lest 2 ms.
+        a, e = self.pmm[3] & 7, self.pmm[3] >> 6
+        timeout = max(302E-6 * (a + 1) * 4**e, 0.002)
+        data = pack("<H", service_index)
+        data = self.send_cmd_recv_rsp(0x0A, data, timeout, check_status=False)
+        if data != b"\xFF\xFF":
+            unpack_format = "<H" if len(data) == 2 else "<HH"
+            return unpack(unpack_format, data)
+
+    def request_system_code(self):
+        """Return all system codes that are registered in the card.
+
+        A card has one or more system codes that correspond to logical
+        partitions (systems). Each system has a system code that could
+        be used in a polling command to activate that system. The
+        system codes responded by the card are returned as a list of
+        16-bit integers. ::
+
+            for system_code in tag.request_system_code():
+                print("System {0:04X}".format(system_code))
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        log.debug("request system code list")
+        a, e = self.pmm[3] & 7, self.pmm[3] >> 6
+        timeout = max(302E-6 * (a + 1) * 4**e, 0.002)
+        data = self.send_cmd_recv_rsp(0x0C, b'', timeout, check_status=False)
+        if len(data) != 1 + data[0] * 2:
+            log.debug("insufficient data received from tag")
+            raise tt3.Type3TagCommandError(tt3.DATA_SIZE_ERROR)
+        return [unpack(">H", data[i:i+2])[0] for i in range(1, len(data), 2)]
+
+
+class FelicaMobile(FelicaStandard):
+    """Mobile FeliCa is a modification of FeliCa for use in mobile
+    phones. This class does currently not implement anything specific
+    beyond recognition of the Mobile FeliCa OS version.
+
+    """
+    IC_CODE_MAP = {
+        # IC   IC-NAME    NBR NBW
+        0x06: ("1.0",       1,  1),
+        0x07: ("1.0",       1,  1),
+        0x10: ("2.0",       1,  1),
+        0x11: ("2.0",       1,  1),
+        0x12: ("2.0",       1,  1),
+        0x13: ("2.0",       1,  1),
+        0x14: ("3.0",       1,  1),
+        0x15: ("3.0",       1,  1),
+        0x16: ("3.0",       1,  1),
+        0x17: ("3.0",       1,  1),
+        0x18: ("3.0",       1,  1),
+        0x19: ("3.0",       1,  1),
+        0x1A: ("3.0",       1,  1),
+        0x1B: ("3.0",       1,  1),
+        0x1C: ("3.0",       1,  1),
+        0x1D: ("3.0",       1,  1),
+        0x1E: ("3.0",       1,  1),
+        0x1F: ("3.0",       1,  1),
+    }
+
+    def __init__(self, clf, target):
+        super(FelicaMobile, self).__init__(clf, target)
+        self._product = "FeliCa Mobile " + self.IC_CODE_MAP[self.pmm[1]][0]
+
+
+class FelicaLite(tt3.Type3Tag):
+    """FeliCa Lite is a version of FeliCa with simplified file system and
+    security functions. The usable memory is 13 blocks (one block has
+    16 byte) plus a one block subtraction register. The tag can be
+    configured with a card key to authenticate the tag and protect
+    integrity of data reads.
+
+    """
+    IC_CODE_MAP = {
+        0xF0: "FeliCa Lite (RC-S965)",
+    }
+
+    class NDEF(tt3.Type3Tag.NDEF):
+        def _read_attribute_data(self):
+            log.debug("FelicaLite.read_attribute_data")
+            attributes = super(FelicaLite.NDEF, self)._read_attribute_data()
+            if attributes is not None and self._tag.is_authenticated:
+                # when authenticated we need to make room for the mac
+                self._original_nbr = attributes['nbr']
+                attributes['nbr'] = min(attributes['nbr'], 3)
+            return attributes
+
+        def _write_attribute_data(self, attributes):
+            log.debug("FelicaLite.read_attribute_data")
+            if self._tag.is_authenticated:
+                attributes = attributes.copy()
+                attributes['nbr'] = self._original_nbr
+            super(FelicaLite.NDEF, self)._write_attribute_data(attributes)
+
+    def __init__(self, clf, target):
+        super(FelicaLite, self).__init__(clf, target)
+        self._product = self.IC_CODE_MAP[self.pmm[1]]
+        self._sk = self._iv = None
+        self.read_from_ndef_service = self.read_without_mac
+        self.write_to_ndef_service = self.write_without_mac
+
+    def dump(self):
+        def oprint(octets):
+            return ' '.join(['%02x' % x for x in octets])
+
+        def cprint(octets):
+            return ''.join([chr(x) if 32 <= x <= 126 else '.' for x in octets])
+
+        userblocks = list()
+        for i in range(0, 14):
+            try:
+                data = self.read_without_mac(i)
+            except tt3.Type3TagCommandError:
+                userblocks.append("{0} |{1}|".format(
+                    " ".join(16 * ["??"]), 16*"."))
+            else:
+                userblocks.append("{0} |{1}|".format(
+                    oprint(data), cprint(data)))
+
+        lines = list()
+        last_block = None
+        same_blocks = 0
+
+        for i, block in enumerate(userblocks):
+            if block == last_block:
+                same_blocks += 1
+                continue
+            if same_blocks:
+                if same_blocks > 1:
+                    lines.append("  *  " + last_block)
+                same_blocks = 0
+            lines.append("{0:3}: ".format(i) + block)
+            last_block = block
+
+        if same_blocks:
+            if same_blocks > 1:
+                lines.append("  *  " + last_block)
+            lines.append("{0:3}: ".format(i) + block)
+
+        data = self.read_without_mac(14)
+        lines.append(" 14: {0} ({1})".format(oprint(data), "REGA[4]B[4]C[8]"))
+
+        text = ("RC1[8], RC2[8]", "MAC[8]", "IDD[8], DFC[2]",
+                "IDM[8], PMM[8]", "SERVICE_CODE[2]",
+                "SYSTEM_CODE[2]", "CKV[2]", "CK1[8], CK2[8]",
+                "MEMORY_CONFIG")
+        config = dict(zip(range(0x80, 0x80+len(text)), text))
+
+        for i in sorted(config.keys()):
+            try:
+                data = self.read_without_mac(i)
+            except tt3.Type3TagCommandError:
+                lines.append("{0:3}: {1}({2})".format(
+                    i, 16 * "?? ", config[i]))
+            else:
+                lines.append("{0:3}: {1} ({2})".format(
+                    i, oprint(data), config[i]))
+
+        return lines
+
+    @staticmethod
+    def generate_mac(data, key, iv, flip_key=False):
+        # Data is first split into tuples of 8 character bytes, each
+        # tuple then reversed and joined, finally all joined back to
+        # one string that is then triple des encrypted with key and
+        # initialization vector iv. If flip_key is True then the key
+        # halfs will be exchanged (this is used to generate a mac for
+        # write). The resulting mac is the last 8 bytes returned in
+        # reversed order.
+        assert len(data) % 8 == 0 and len(key) == 16 and len(iv) == 8
+        key = bytes(key[8:] + key[:8]) if flip_key else bytes(key)
+        txt = b''.join([
+            struct.pack("{}B".format(len(x)), *reversed(x))
+            if isinstance(x[0], int)
+            else b''.join(reversed(x))
+            for x in zip(*[iter(bytes(data))]*8)])
+        return bytearray(triple_des(key, CBC, bytes(iv)).encrypt(txt)[:-9:-1])
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """Protect a FeliCa Lite Tag.
+
+        A FeliCa Lite Tag can be provisioned with a custom password
+        (or the default manufacturer key if the password is an empty
+        string or bytearray) to ensure that data retrieved by future
+        read operations, after authentication, is genuine. Read
+        protection is not supported.
+
+        A non-empty *password* must provide at least 128 bit key
+        material, in other words it must be a string or bytearray of
+        length 16 or more.
+
+        The memory unit for the value of *protect_from* is 16 byte,
+        thus with ``protect_from=2`` bytes 0 to 31 are not protected.
+        If *protect_from* is zero (the default value) and the Tag has
+        valid NDEF management data, the NDEF RW Flag is set to read
+        only.
+
+        """
+        return super(FelicaLite, self).protect(
+            password, read_protect, protect_from)
+
+    def _protect(self, password, read_protect, protect_from):
+        if password and len(password) < 16:
+            raise ValueError("password must be at least 16 byte")
+
+        if protect_from < 0:
+            raise ValueError("protect_from can not be negative")
+
+        if read_protect:
+            log.info("this tag can not be made read protected")
+            return False
+
+        # The memory configuration block contains access permissions
+        # and ndef compatibility information.
+        mc = self.read_without_mac(0x88)
+
+        if password is not None:
+            if mc[2] != 0xFF:
+                log.info("system block protected, can't write key")
+                return False
+
+            # if password is empty use factory key of 16 zero bytes
+            key = password[0:16] if password else b"\0"*16
+
+            log.debug("protect with key %s", hexlify(key).decode())
+            self.write_without_mac(key[7::-1] + key[15:7:-1], 0x87)
+
+        if protect_from < 14:
+            log.debug("write protect blocks {0}--13".format(protect_from))
+            mc[0:2] = pack("<H", 0x7FFF ^ (2**14 - 2**protect_from))
+
+        if protect_from == 0 and self.ndef is not None:
+            attribute_data = self.read_without_mac(0)
+            attribute_data[10] = 0x00
+            attribute_data[14:16] = pack('>H', sum(attribute_data[0:14]))
+            self.write_without_mac(attribute_data, 0)
+
+        log.debug("write protect system blocks 82,83,84,86,87")
+        mc[2] = 0x00  # set system blocks 82,83,84,86,87 to read only
+
+        log.debug("write memory configuration %s", hexlify(mc).decode())
+        self.write_without_mac(mc, 0x88)
+        return True
+
+    def authenticate(self, password):
+        """Authenticate a FeliCa Lite Tag.
+
+        A FeliCa Lite Tag is authenticated by a procedure that allows
+        both the reader and the tag to calculate a session key from a
+        random challenge send by the reader and a key that is securely
+        stored on the tag and provided to :meth:`authenticate` as the
+        *password* argument. If the tag was protected with an earlier
+        call to :meth:`protect` then the same password should
+        successfully authenticate.
+
+        After authentication the :meth:`read_with_mac` method can be
+        used to read data such that it can not be falsified on
+        transmission.
+
+        """
+        return super(FelicaLite, self).authenticate(password)
+
+    def _authenticate(self, password):
+        if password and len(password) < 16:
+            raise ValueError("password must be at least 16 byte")
+
+        # Perform internal authentication, i.e. ensure that the tag
+        # has the same card key as in password. If the password is
+        # empty, we'll try with the factory key.
+        key = b"\0" * 16 if not password else password[0:16]
+
+        log.debug("authenticate with key {}".format(hexlify(key).decode()))
+        self._authenticated = False
+        self.read_from_ndef_service = self.read_without_mac
+        self.write_to_ndef_service = self.write_without_mac
+
+        # Internal authentication starts with a random challenge (rc1 || rc2)
+        # that we write to the rc block. Because the tag works little endian,
+        # we reverse the order of rc1 and rc2 bytes when writing.
+        rc = os.urandom(16)
+        log.debug("rc1 = {}".format(hexlify(rc[:8]).decode()))
+        log.debug("rc2 = {}".format(hexlify(rc[8:]).decode()))
+        self.write_without_mac(rc[7::-1] + rc[15:7:-1], 0x80)
+
+        # The session key becomes the triple_des encryption of the random
+        # challenge under the card key and with an initialization vector of
+        # all zero.
+        sk = triple_des(key, CBC, b'\00' * 8).encrypt(rc)
+        log.debug("sk1 = {}".format(hexlify(sk[:8]).decode()))
+        log.debug("sk2 = {}".format(hexlify(sk[8:]).decode()))
+
+        # By reading the id and mac block together we get the mac that the
+        # tag has generated over the id block data under it's session key
+        # generated the same way as we did) and with rc1 as the
+        # initialization vector.
+        data = self.read_without_mac(0x82, 0x81)
+
+        # Now we check if we calculate the same mac with our session key.
+        # Note that, because of endianess, data must be reversed in chunks
+        # of 8 bytes as does the 8 byte mac - this is all done within the
+        # generate_mac() function.
+        if data[-16:-8] == self.generate_mac(data[0:-16], sk, iv=rc[0:8]):
+            log.debug("tag authentication completed")
+            self._sk = sk
+            self._iv = rc[0:8]
+            self._authenticated = True
+            self.read_from_ndef_service = self.read_with_mac
+        else:
+            log.debug("tag authentication failed")
+
+        return self._authenticated
+
+    def format(self, version=0x10, wipe=None):
+        """Format a FeliCa Lite Tag for NDEF.
+
+        """
+        return super(FelicaLite, self).format(version, wipe)
+
+    def _format(self, version, wipe):
+        assert type(version) is int
+        assert wipe is None or type(wipe) is int
+
+        if version and version >> 4 != 1:
+            log.error("type 3 tag ndef mapping major version must be 1")
+            return False
+
+        # The memory configuration block contains access permissions
+        # and ndef compatibility information.
+        mc = self.read_without_mac(0x88)
+
+        if mc[0] & 0x01 != 0x01:
+            log.info("the first user data block is not writeable")
+            return False
+
+        if not mc[3] & 0x01:  # ndef compatibility flag
+            if mc[2] == 0xFF:  # mc block is writeable
+                mc[3] = mc[3] | 0x01
+                self.write_without_mac(mc, 0x88)
+            else:
+                log.info("this tag can no longer be changed to ndef")
+                return False
+
+        # Count the number of writeable data blocks (that is excluding
+        # the attribute block) from the least significant read/write
+        # permission bits that are consecutively set to 1.
+        rw_bits = unpack("<H", mc[0:2])[0]
+        for nmaxb in range(14):
+            if rw_bits >> (nmaxb + 1) & 1 == 0:
+                break
+
+        # Create and write the attribute data. Version number, Nbr and
+        # Nbw are fix and we have just determined Nmaxb.
+        attribute_data = bytearray(16)
+        attribute_data[:14] = pack(">BBBHxxxxxBxxx", version, 4, 1, nmaxb, 1)
+        attribute_data[14:] = pack(">H", sum(attribute_data[:14]))
+        log.debug("set ndef attributes %s", hexlify(attribute_data).decode())
+        self.write_without_mac(attribute_data, 0)
+
+        # Overwrite the ndef message area if a wipe is requested.
+        if wipe is not None:
+            data = bytearray(16 * [wipe])
+            for block in range(1, nmaxb+1):
+                self.write_without_mac(data, block)
+
+        return True
+
+    def read_without_mac(self, *blocks):
+        """Read a number of data blocks without integrity check.
+
+        This method accepts a variable number of integer arguments as
+        the block numbers to read. The blocks are read with service
+        code 0x000B (NDEF).
+
+        Tag command errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        log.debug("read {0} block(s) without mac".format(len(blocks)))
+        service_list = [tt3.ServiceCode(0, 0b001011)]
+        block_list = [tt3.BlockCode(n) for n in blocks]
+        return self.read_without_encryption(service_list, block_list)
+
+    def read_with_mac(self, *blocks):
+        """Read a number of data blocks with integrity check.
+
+        This method accepts a variable number of integer arguments as
+        the block numbers to read. The blocks are read with service
+        code 0x000B (NDEF). Along with the requested block data the
+        tag returns a message authentication code that is verified
+        before data is returned. If verification fails the return
+        value of :meth:`read_with_mac` is None.
+
+        A :exc:`RuntimeError` exception is raised if the tag was not
+        authenticated before calling this method.
+
+        Tag command errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        log.debug("read {0} block(s) with mac".format(len(blocks)))
+
+        if self._sk is None or self._iv is None:
+            raise RuntimeError("authentication required")
+
+        service_list = [tt3.ServiceCode(0, 0b001011)]
+        block_list = [tt3.BlockCode(n) for n in blocks]
+        block_list.append(tt3.BlockCode(0x81))
+
+        data = self.read_without_encryption(service_list, block_list)
+        data, mac = data[0:-16], data[-16:-8]
+        if mac != self.generate_mac(data, self._sk, self._iv):
+            log.warning("mac verification failed")
+        else:
+            return data
+
+    def write_without_mac(self, data, block):
+        """Write a data block without integrity check.
+
+        This is the standard write method for a FeliCa Lite. The
+        16-byte string or bytearray *data* is written to the numbered
+        *block* in service 0x0009 (NDEF write service). ::
+
+            data = bytearray(range(16)) # 0x00, 0x01, ... 0x0F
+            try: tag.write_without_mac(data, 5) # write block 5
+            except nfc.tag.TagCommandError:
+                print("something went wrong")
+
+        Tag command errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        # Write a single data block without a mac. Write with mac is
+        # only supported by FeliCa Lite-S.
+        assert len(data) == 16 and type(block) is int
+        log.debug("write 1 block without mac".format())
+        sc_list = [tt3.ServiceCode(0, 0b001001)]
+        bc_list = [tt3.BlockCode(block)]
+        self.write_without_encryption(sc_list, bc_list, data)
+
+
+class FelicaLiteS(FelicaLite):
+    """FeliCa Lite-S is a version of FeliCa Lite with enhanced security
+    functions. It provides mutual authentication were both the tag and
+    the reader must demonstrate posession of the card key before data
+    writes can be made. It is also possible to require mutual
+    authentication for data reads.
+
+    """
+    IC_CODE_MAP = {
+        0xF1: "FeliCa Lite-S (RC-S966)",
+        0xF2: "FeliCa Link (RC-S730) Lite-S Mode",
+    }
+
+    class NDEF(FelicaLite.NDEF):
+        def _read_attribute_data(self):
+            log.debug("FelicaLiteS.read_attribute_data")
+            attributes = super(FelicaLiteS.NDEF, self)._read_attribute_data()
+            if attributes is not None and self._tag._authenticated:
+                # when authenticated and user data is writeable
+                mc = self._tag.read_without_mac(0x88)
+                rw_bits = unpack("<H", mc[0:2])[0]
+                self._writeable = bool(rw_bits & 0x3ff == 0x3ff)
+            return attributes
+
+    def __init__(self, clf, target):
+        super(FelicaLiteS, self).__init__(clf, target)
+        self._product = self.IC_CODE_MAP[self.pmm[1]]
+
+    def dump(self):
+        def oprint(octets):
+            return ' '.join(['%02x' % x for x in octets])
+
+        lines = super(FelicaLiteS, self).dump()
+
+        text = ("WCNT[3]", "MAC_A[8]", "STATE")
+        config = dict(zip(range(0x90, 0x90+len(text)), text))
+
+        for i in sorted(config.keys()):
+            try:
+                data = self.read_without_mac(i)
+            except tt3.Type3TagCommandError:
+                lines.append("{0:3}: {1}({2})".format(
+                    i, 16 * "?? ", config[i]))
+            else:
+                lines.append("{0:3}: {1} ({2})".format(
+                    i, oprint(data), config[i]))
+
+        return lines
+
+    def protect(self, password=None, read_protect=False, protect_from=0):
+        """Protect a FeliCa Lite-S Tag.
+
+        A FeliCa Lite-S Tag can be write and read protected with a
+        custom password (or the default manufacturer key if the
+        password is an empty string or bytearray). Note that the
+        *read_protect* flag is only evaluated when a *password* is
+        provided.
+
+        A non-empty *password* must provide at least 128 bit key
+        material, in other words it must be a string or bytearray of
+        length 16 or more.
+
+        The memory unit for the value of *protect_from* is 16 byte,
+        thus with ``protect_from=2`` bytes 0 to 31 are not protected.
+        If *protect_from* is zero (the default value) and the Tag has
+        valid NDEF management data, the NDEF RW Flag is set to read
+        only.
+
+        """
+        return super(FelicaLite, self).protect(
+            password, read_protect, protect_from)
+
+    def _protect(self, password, read_protect, protect_from):
+        if password and len(password) < 16:
+            raise ValueError("password must be at least 16 byte")
+
+        if protect_from < 0:
+            raise ValueError("protect_from can not be negative")
+
+        # The memory configuration block contains access permissions
+        # and ndef compatibility information.
+        mc = self.read_without_mac(0x88)
+
+        if password is not None:
+            if mc[2] != 0xFF:  # system block protected
+                if mc[5] & 1 == 0:  # key change disabled
+                    log.info("card key can not be changed")
+                    return False
+                if self._authenticated is False:
+                    log.info("authentication required to change key")
+                    return False
+
+            # if password is empty use factory key of 16 zero bytes
+            key = password[0:16].encode("ascii") if password else b'\0' * 16
+
+            log.debug("protect with key %s", hexlify(key).decode())
+            ckv = self.read_without_mac(0x86)
+            ckv = min(unpack("<H", ckv[0:2])[0] + 1, 0xffff)
+            log.debug("new card key version is {0}".format(ckv))
+            self.write_without_mac(pack("<H", ckv) + b"\0" * 14, 0x86)
+            self.write_without_mac(key[7::-1] + key[15:7:-1], 0x87)
+
+            if not self.authenticate(key):
+                log.error("failed to authenticate with new card key")
+                return False
+
+            if read_protect and protect_from < 14:
+                log.debug("read protect blocks {0}--13".format(protect_from))
+                protect_mask = pack("<H", 2**14 - 2**protect_from)
+                mc[6:8] = protect_mask
+
+        if protect_from < 14:
+            log.debug("write protect blocks {0}--13".format(protect_from))
+            protect_mask = pack("<H", 2**14 - 2**protect_from)
+            mc[8:10] = mc[10:12] = protect_mask
+
+        if protect_from == 0 and self.ndef is not None:
+            attribute_data = self.read_without_mac(0)
+            attribute_data[10] = 0x00
+            attribute_data[14:16] = pack('>H', sum(attribute_data[0:14]))
+            self.write_without_mac(attribute_data, 0)
+
+        log.debug("write protect system blocks 82,83,84,86,87")
+        mc[2] = 0x00  # set system blocks 82,83,84,86,87 to read only
+        mc[5] = 0x01  # but allow write with mac to ck and ckv block
+
+        # Write the new memory control block.
+        log.debug("write memory configuration %s", hexlify(mc).decode())
+        self.write_without_mac(mc, 0x88)
+        return True
+
+    def authenticate(self, password):
+        """Mutually authenticate with a FeliCa Lite-S Tag.
+
+        FeliCa Lite-S supports enhanced security functions, one of
+        them is the mutual authentication performed by this
+        method. The first part of mutual authentication is to
+        authenticate the tag with :meth:`FelicaLite.authenticate`. If
+        successful, the shared session key is used to generate the
+        integrity check value for write operation to update a specific
+        memory block. If that was successful then the tag is ensured
+        that the reader has the correct card key.
+
+        After successful authentication the
+        :meth:`~FelicaLite.read_with_mac` and :meth:`write_with_mac`
+        methods can be used to read and write data such that it can
+        not be falsified on transmission.
+
+        """
+        if super(FelicaLiteS, self).authenticate(password):
+            # At this point we have achieved internal authentication,
+            # i.e we know that the tag has the same card key as in
+            # password. We now reset the authentication status and do
+            # external authentication to assure the tag that we have
+            # the right card key.
+            self._authenticated = False
+            self.read_from_ndef_service = self.read_without_mac
+            self.write_to_ndef_service = self.write_without_mac
+
+            # To authenticate to the tag we write a 01h into the
+            # ext_auth byte of the state block (block 0x92). The other
+            # bytes of the state block can be all set to zero.
+            self.write_with_mac(b"\x01" + 15*b"\0", 0x92)
+
+            # Now read the state block and check the value of the
+            # ext_auth to see if we are authenticated. If it's 01h
+            # then we are, otherwise not.
+            if self.read_with_mac(0x92)[0] == 0x01:
+                log.debug("mutual authentication completed")
+                self._authenticated = True
+                self.read_from_ndef_service = self.read_with_mac
+                self.write_to_ndef_service = self.write_with_mac
+            else:
+                log.debug("mutual authentication failed")
+
+        return self._authenticated
+
+    def write_with_mac(self, data, block):
+        """Write one data block with additional integrity check.
+
+        If prior to calling this method the tag was not authenticated,
+        a :exc:`RuntimeError` exception is raised.
+
+        Command execution errors raise :exc:`~nfc.tag.TagCommandError`.
+
+        """
+        # Write a single data block protected with a mac. The card
+        # will only accept the write if it computed the same mac.
+        log.debug("write 1 block with mac")
+        if len(data) != 16:
+            raise ValueError("data must be 16 octets")
+        if type(block) is not int:
+            raise ValueError("block number must be int")
+        if self._sk is None or self._iv is None:
+            raise RuntimeError("tag must be authenticated first")
+
+        # The write count is the first three byte of the wcnt block.
+        wcnt = self.read_without_mac(0x90)[0:3]
+        log.debug("write count is %s", hexlify(wcnt[::-1]).decode())
+
+        # We must generate the mac_a block to write the data. The data
+        # to encrypt to the mac is composed of write count and block
+        # numbers (8 byte) and the data we want to write. The mac for
+        # write must be generated with the key flipped (sk2 || sk1).
+        def flip(sk):
+            return sk[8:16] + sk[0:8]
+
+        data = wcnt + b"\x00" + bytearray([block]) + b"\x00\x91\x00" + data
+        maca = self.generate_mac(data, flip(self._sk), self._iv) + wcnt+5*b"\0"
+
+        # Now we can write the data block with our computed mac to the
+        # desired block and the maca block. Write without encryption
+        # means that the data is not encrypted with a service key.
+        sc_list = [tt3.ServiceCode(0, 0b001001)]
+        bc_list = [tt3.BlockCode(block), tt3.BlockCode(0x91)]
+        self.write_without_encryption(sc_list, bc_list, data[8:24] + maca)
+
+
+class FelicaPlug(tt3.Type3Tag):
+    """FeliCa Plug is a contactless communication interface module for
+    microcontrollers.
+
+    """
+    IC_CODE_MAP = {
+        0xE0: "FeliCa Plug (RC-S926)",
+        0xE1: "FeliCa Link (RC-S730) Plug Mode",
+    }
+
+    def __init__(self, clf, target):
+        super(FelicaPlug, self).__init__(clf, target)
+        self._product = self.IC_CODE_MAP[self.pmm[1]]

src/lib/nfc/tag/tt4.py

@@ -0,0 +1,579 @@
+# -*- coding: latin-1 -*-
+# -----------------------------------------------------------------------------
+# Copyright 2012, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
+#
+# 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:
+#
+# https://joinup.ec.europa.eu/software/page/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 itertools
+from binascii import hexlify
+from struct import pack, unpack
+
+import nfc.tag
+import nfc.clf
+
+import logging
+log = logging.getLogger(__name__)
+
+
+ndef_aid_v1 = bytearray.fromhex("D2760000850100")
+ndef_aid_v2 = bytearray.fromhex("D2760000850101")
+
+
+class Type4TagCommandError(nfc.tag.TagCommandError):
+    """Type 4 Tag exception class. Beyond the generic error values from
+    :attr:`~nfc.tag.TagCommandError` this class covers ISO 7816-4
+    response APDU error codes.
+
+    """
+    errno_str = {
+        # ISO/IEC 7816-4 (2005) APDU errors (SW1/SW2)
+        0x6700: "wrong lenght (general error)",
+        0x6900: "command not allowed (general error)",
+        0x6981: "command incompatible with file structure",
+        0x6982: "security status not satisfied",
+        0x6A00: "wrong parameters p1/p2 (general error)",
+        0x6A80: "incorrect parameters in command data field",
+        0x6A81: "function not supported",
+        0x6A82: "file or application not found",
+        0x6A83: "record not found",
+        0x6A84: "not enough memory space in the file",
+        0x6A85: "command length inconsistent with TLV structure",
+        0x6A86: "incorrect parameters p1/p2",
+        0x6A87: "command length inconsistent with p1/p2",
+        0x6A88: "referenced data or reference data not found",
+        0x6A89: "file already exists",
+        0x6A8A: "file name already exists",
+    }
+
+    @staticmethod
+    def from_status(status):
+        return Type4TagCommandError(unpack(">H", status)[0])
+
+
+class IsoDepInitiator(object):
+    def __init__(self, clf, fsc, fwt):
+        self.clf = clf
+        self.pni = 0
+        self.miu = fsc - 3  # account for 1 byte PCB and 2 byte EDC
+        self.fwt = fwt
+        self.delta_fwt = 49152 / 13.56E6
+        self.n_retry_ack = min(int(1/self.fwt), 5)
+        self.n_retry_nak = self.n_retry_ack
+
+    def exchange(self, command, timeout=None):
+        if timeout is None:
+            timeout = self.fwt + self.delta_fwt
+
+        if command is None:
+            # presence check with R(NAK)
+            data = bytearray([0xB2 | self.pni])
+            self.clf.exchange(data, timeout)
+            return
+
+        for offset in range(0, len(command), self.miu):
+            more = len(command) - offset > self.miu
+            pfb = pack('B', (0x02, 0x12)[more] | self.pni)
+            data = pfb + command[offset:offset+self.miu]
+
+            for i in itertools.count(start=1):  # pragma: no branch
+                try:
+                    data = self.clf.exchange(data, timeout)
+                    if len(data) == 0:
+                        raise nfc.clf.TransmissionError
+                    if data[0] == 0xA2 | (~self.pni & 1):
+                        log.debug("ISO-DEP retransmit after ack")
+                        data = pfb + command[offset:offset+self.miu]
+                        continue
+                    break
+                except nfc.clf.TransmissionError:
+                    if i <= self.n_retry_nak:
+                        log.warning("ISO-DEP transmission error (#%d)" % i)
+                        data = bytearray([0xB2 | self.pni])
+                    else:
+                        log.error("ISO-DEP unrecoverable transmission error")
+                        raise Type4TagCommandError(nfc.tag.RECEIVE_ERROR)
+                except nfc.clf.TimeoutError:
+                    if i <= self.n_retry_nak:
+                        log.warning("ISO-DEP timeout error (#%d)" % i)
+                        data = bytearray([0xB2 | self.pni])
+                    else:
+                        log.error("ISO-DEP unrecoverable timeout error")
+                        raise Type4TagCommandError(nfc.tag.TIMEOUT_ERROR)
+                except nfc.clf.ProtocolError:
+                    log.error("ISO-DEP unrecoverable protocol error")
+                    raise Type4TagCommandError(nfc.tag.PROTOCOL_ERROR)
+
+            while data[0] & 0b11111110 == 0b11110010:  # WTX
+                log.debug("ISO-DEP waiting time extension")
+                data = self.clf.exchange(data, (data[1] & 0x3F) * self.fwt)
+
+            if data[0] & 0x01 != self.pni:
+                log.warning("ISO-DEP protocol error: block number")
+                raise Type4TagCommandError(nfc.tag.PROTOCOL_ERROR)
+
+            if more:
+                if data[0] & 0b11111110 == 0b10100010:  # ACK
+                    self.pni = (self.pni + 1) % 2
+                else:
+                    log.error("ISO-DEP protocol error: expected ack")
+                    raise Type4TagCommandError(nfc.tag.PROTOCOL_ERROR)
+            else:
+                if data[0] & 0b11101110 == 0x02:  # INF
+                    self.pni = (self.pni + 1) % 2
+                    response = data[1:]
+                else:
+                    log.error("ISO-DEP protocol error: expected inf")
+                    raise Type4TagCommandError(nfc.tag.PROTOCOL_ERROR)
+
+        while bool(data[0] & 0b00010000):
+            data = pack('B', 0xA2 | self.pni)  # ACK
+
+            for i in itertools.count(start=1):  # pragma: no branch
+                try:
+                    data = self.clf.exchange(data, timeout)
+                    if len(data) == 0:
+                        raise nfc.clf.TransmissionError
+                    break
+                except nfc.clf.TransmissionError:
+                    if i <= self.n_retry_ack:
+                        log.warning("ISO-DEP transmission error  (#%d)" % i)
+                        data = bytearray([0xA2 | self.pni])
+                    else:
+                        log.error("ISO-DEP unrecoverable transmission error")
+                        raise Type4TagCommandError(nfc.tag.RECEIVE_ERROR)
+                except nfc.clf.TimeoutError:
+                    if i <= self.n_retry_ack:
+                        log.warning("ISO-DEP timeout error (#%d)" % i)
+                        data = bytearray([0xA2 | self.pni])
+                    else:
+                        log.error("ISO-DEP unrecoverable timeout error")
+                        raise Type4TagCommandError(nfc.tag.TIMEOUT_ERROR)
+                except nfc.clf.ProtocolError:
+                    log.error("ISO-DEP unrecoverable protocol error")
+                    raise Type4TagCommandError(nfc.tag.PROTOCOL_ERROR)
+
+            if data[0] & 0x01 != self.pni:
+                log.error("ISO-DEP protocol error: block number")
+                raise Type4TagCommandError(nfc.tag.PROTOCOL_ERROR)
+
+            response = response + data[1:]
+            self.pni = (self.pni + 1) % 2
+
+        return response
+
+
+class Type4Tag(nfc.tag.Tag):
+    """Implementation of the NFC Forum Type 4 Tag operation specification.
+
+    The NFC Forum Type 4 Tag is based on ISO/IEC 14443 DEP protocol
+    for Type A and B modulation and uses ISO/IEC 7816-4 command and
+    response APDUs.
+
+    """
+    TYPE = "Type4Tag"
+
+    class NDEF(nfc.tag.Tag.NDEF):
+        # Type 4 Tag specific implementation of the NDEF access type
+        # class that is returned by the Tag.ndef attribute.
+
+        def _select_ndef_application(self):
+            for self._aid, mrl in ((ndef_aid_v2, 256), (ndef_aid_v1, 0)):
+                try:
+                    self.tag.send_apdu(0, 0xA4, 0x04, 0x00, self._aid, mrl)
+                    log.debug("selected %s", hexlify(self._aid).decode())
+                    return True
+                except Type4TagCommandError as error:
+                    if error.errno <= 0:
+                        break
+
+        def _select_fid(self, fid):
+            p2 = 0x00 if self._aid == ndef_aid_v1 else 0x0C
+            try:
+                self.tag.send_apdu(0, 0xA4, 0x00, p2, fid)
+                log.debug("selected %s", hexlify(fid).decode())
+                return True
+            except Type4TagCommandError:
+                log.debug("failed to select %s", hexlify(fid).decode())
+
+        def _read_binary(self, offset, size):
+            (p1, p2) = pack(">H", offset)
+            max_data = min(self._max_le, size)
+            log.debug("read_binary from %d to %d", offset, offset + max_data)
+            return self.tag.send_apdu(0, 0xB0, p1, p2, mrl=max_data)
+
+        def _update_binary(self, offset, data):
+            (p1, p2) = pack(">H", offset)
+            max_data = min(self._max_lc, len(data))
+            log.debug("update_binary from %d to %d", offset, offset + max_data)
+            self.tag.send_apdu(0, 0xD6, p1, p2, data[:max_data])
+            return max_data
+
+        def _discover_ndef(self):
+            self._max_lc = 1
+            self._max_le = 15
+
+            log.debug("select ndef application")
+            if not self._select_ndef_application():
+                log.debug("no ndef application file")
+                return False
+
+            log.debug("select ndef capability file")
+            if not self._select_fid(b"\xE1\x03"):
+                log.warning("no ndef capability file")
+                return False
+
+            log.debug("read ndef capability file")
+            cclen = self._read_binary(0, 2)
+            if not (cclen and len(cclen) == 2):
+                log.debug("error reading capability length")
+                return False
+
+            cclen = unpack(">H", cclen)[0]
+            capabilities = self._read_binary(2, min(cclen-2, 15))
+
+            if capabilities is None or len(capabilities) < 13:
+                log.warning("insufficient capability data")
+                return False
+
+            capabilities += (15-len(capabilities)) * b"\0"  # for unpack
+            ver, mle, mlc, tag, val = unpack(">BHHB9p", capabilities)
+            log.debug("ndef mapping version %d.%d", ver >> 4, ver & 15)
+            log.debug("max apdu response length %d", mle)
+            log.debug("max apdu command length %d", mlc)
+            log.debug("ndef file control tlv tag %d", tag)
+
+            if ver >> 4 not in (1, 2, 3):
+                log.debug("unsupported major ndef version")
+                return False
+
+            if not (tag, len(val)) in ((4, 6), (6, 8)):
+                log.error("invalid ndef control tlv")
+                return False
+
+            ndef_control_tlv_format = ">2sHBB" if tag == 4 else ">2sIBB"
+            ndef_file, mfs, rf, wf = unpack(ndef_control_tlv_format, val)
+            log.debug("ndef file identifier %s", hexlify(ndef_file).decode())
+            log.debug("ndef file size limit %d", mfs)
+            log.debug("ndef file read flag is %d", rf)
+            log.debug("ndef file write flag is %d", wf)
+
+            self._max_le = mle
+            self._max_lc = mlc
+            self._capacity = mfs - tag + 2
+            self._readable = bool(rf == 0)
+            self._writeable = bool(wf == 0)
+            self._nlen_size = tag - 2
+            self._ndef_file = ndef_file
+
+            return True
+
+        def _read_ndef_data(self):
+            log.debug("read ndef data")
+
+            try:
+                if not (hasattr(self, "_ndef_file") or self._discover_ndef()):
+                    log.debug("no ndef application")
+                    return None
+
+                log.debug("select ndef data file")
+                if not self._select_fid(self._ndef_file):
+                    log.warning("ndef file select error")
+                    return None
+
+                log.debug("read ndef data file")
+                lfmt = ">I" if self._nlen_size == 4 else ">H"
+                nlen = self._read_binary(0, self._nlen_size)
+                if len(nlen) != self._nlen_size:
+                    return None
+
+                nlen = unpack(lfmt, nlen)[0]
+                log.debug("ndef data length is {0}".format(nlen))
+
+                data = bytearray()
+                while len(data) < nlen:
+                    offset = self._nlen_size + len(data)
+                    data += self._read_binary(offset, nlen - len(data))
+
+            except Type4TagCommandError:
+                return None
+            else:
+                return data
+
+        def _write_ndef_data(self, data):
+            log.debug("write ndef data")
+
+            lfmt = ">I" if self._nlen_size == 4 else ">H"
+            nlen = bytearray(pack(lfmt, len(data)))
+            if len(nlen) + len(data) <= self._max_lc:
+                data = bytearray(nlen) + data
+                nlen = None
+            else:
+                data = bytearray(len(nlen)) + data
+
+            offset = 0
+            while offset < len(data):
+                offset += self._update_binary(offset, data[offset:])
+
+            if nlen:
+                self._update_binary(0, nlen)
+
+            return True
+
+        def _wipe_ndef_data(self, wipe=None):
+            lfmt = ">I" if self._nlen_size == 4 else ">H"
+            nlen = bytearray(pack(lfmt, 0))
+            self._update_binary(0, nlen)
+            offset = self._nlen_size
+            data = bytearray(self._capacity * [wipe % 256])
+            while offset < self.capacity:
+                offset += self._update_binary(offset, data[offset:])
+
+        def _dump_ndef_data(self):
+            lines = []
+            for offset in itertools.count(0, 16):  # pragma: no branch
+                try:
+                    line = self._read_binary(offset, 16)
+                    if len(line) > 0:
+                        lines.append(line)
+                    if len(line) < 16:
+                        break
+                except Type4TagCommandError:
+                    break
+
+            return lines
+
+    def _is_present(self):
+        try:
+            self._dep.exchange(None)
+            return True
+        except nfc.clf.CommunicationError:
+            return False
+
+    def dump(self):
+        """Returns tag data as a list of formatted strings.
+
+        The :meth:`dump` method provides useful output only for NDEF
+        formatted Type 4 Tags. Each line that is returned contains a
+        hexdump of 16 octets from the NDEF data file.
+
+        """
+        return self._dump()
+
+    def _dump(self):
+        def oprint(octets):
+            return ' '.join(['%02x' % x for x in octets])
+
+        def cprint(octets):
+            return ''.join([chr(x) if 32 <= x <= 126 else '.' for x in octets])
+
+        def lprint(fmt, octets, index):
+            return fmt.format(index, oprint(octets), cprint(octets))
+
+        lfmt = "0x{0:04x}: {1} |{2}|"
+
+        if self.ndef and self.ndef.is_readable:
+            lines = self.ndef._dump_ndef_data()
+            return [lprint(lfmt, d, i << 4) for i, d in enumerate(lines)]
+
+        return []
+
+    def format(self, version=None, wipe=None):
+        """Erase the NDEF message on a Type 4 Tag.
+
+        The :meth:`format` method writes the length of the NDEF
+        message on a Type 4 Tag to zero, thus the tag will appear to
+        be empty. If the *wipe* argument is set to some integer then
+        :meth:`format` will also overwrite all user data with that
+        integer (mod 256).
+
+        Despite it's name, the :meth:`format` method can not format a
+        blank tag to make it NDEF compatible; this requires
+        proprietary information from the manufacturer.
+
+        """
+        return super(Type4Tag, self).format(version, wipe)
+
+    def _format(self, version, wipe):
+        if not self.ndef or not self.ndef.is_writeable:
+            log.error("format error: no ndef or not writeable")
+            return False
+
+        if wipe is not None:
+            try:
+                self.ndef._wipe_ndef_data(wipe)
+            except Type4TagCommandError as error:
+                log.error("format error: %s", str(error))
+                return False
+
+        return True
+
+    def transceive(self, data, timeout=None):
+        """Transmit arbitrary data and receive the response.
+
+        This is a low level method to send arbitrary data to the
+        tag. While it should almost always be better to use
+        :meth:`send_apdu` this is the only way to force a specific
+        timeout value (which is otherwise derived from the Tag's
+        answer to select). The *timeout* value is expected as a float
+        specifying the seconds to wait.
+
+        """
+        log.debug(">> {0}".format(hexlify(data).decode()))
+        data = self._dep.exchange(data, timeout)
+        log.debug("<< {0}".format(hexlify(data).decode() if data else "None"))
+        return data
+
+    def send_apdu(self, cla, ins, p1, p2, data=None, mrl=0, check_status=True):
+        """Send an ISO/IEC 7816-4 APDU to the Type 4 Tag.
+
+        The 4 byte APDU header (class, instruction, parameter 1 and 2)
+        is constructed from the first four parameters (cla, ins, p1,
+        p2) without interpretation. The byte string *data* argument
+        represents the APDU command data field. It is encoded as a
+        short or extended length field followed by the *data*
+        bytes. The length field is not transmitted if *data* is None
+        or an empty string. The maximum acceptable number of response
+        data bytes is given with the max-response-length *mrl*
+        argument. The value of *mrl* is transmitted as the 7816-4 APDU
+        Le field after appropriate conversion.
+
+        By default, the response is returned as a byte array not
+        including the status word, a :exc:`Type4TagCommandError`
+        exception is raised for any status word other than
+        9000h. Response status verification can be disabled with
+        *check_status* set to False, the byte array will then include
+        the response status word at the last two positions.
+
+        Transmission errors always raise a :exc:`Type4TagCommandError`
+        exception.
+
+        """
+        apdu = bytearray([cla, ins, p1, p2])
+
+        if not self._extended_length_support:
+            if data and len(data) > 255:
+                raise ValueError("unsupported command data length")
+            if mrl and mrl > 256:
+                raise ValueError("unsupported max response length")
+            if data:
+                apdu += pack('>B', len(data)) + bytes(data)
+            if mrl > 0:
+                apdu += pack('>B', 0 if mrl == 256 else mrl)
+        else:
+            if data and len(data) > 65535:
+                raise ValueError("invalid command data length")
+            if mrl and mrl > 65536:
+                raise ValueError("invalid max response length")
+            if data:
+                apdu += pack(">xH", len(data)) + bytes(data)
+            if mrl > 0:
+                le = 0 if mrl == 65536 else mrl
+                apdu += pack(">H", le) if data else pack(">xH", le)
+
+        apdu = self.transceive(apdu)
+
+        if not apdu or len(apdu) < 2:
+            raise Type4TagCommandError(nfc.tag.PROTOCOL_ERROR)
+
+        if check_status and apdu[-2:] != b"\x90\x00":
+            raise Type4TagCommandError.from_status(apdu[-2:])
+
+        return apdu[:-2] if check_status else apdu
+
+    def __str__(self):
+        s = "{tag.__class__.__name__} MIU={tag._dep.miu} FWT={tag._dep.fwt:f}"
+        return s.format(tag=self)
+
+
+class Type4ATag(Type4Tag):
+    def __init__(self, clf, target):
+        super(Type4ATag, self).__init__(clf, target)
+        self._nfcid = bytearray(target.sdd_res)
+
+        log.debug("send RATS command to activate the Type 4A Tag")
+        if self.clf.max_recv_data_size < 256:
+            log.warning("{0} does not support fsd 256".format(self.clf))
+            rats_cmd = bytearray.fromhex("E0 70")
+        else:
+            rats_cmd = bytearray.fromhex("E0 80")
+        rats_res = self.clf.exchange(rats_cmd, timeout=0.03)
+        log.debug("rcvd RATS response: {0}".format(hexlify(rats_res).decode()))
+
+        fsci, fwti = rats_res[1] & 0x0F, rats_res[3] >> 4
+        if fsci > 8:
+            log.warning("FSCI with RFU value in RATS_RES")
+            fsci = 8
+        if fwti > 14:
+            log.warning("FWI with RFU value in RATS_RES")
+            fwti = 4
+
+        fsc = (16, 24, 32, 40, 48, 64, 96, 128, 256)[fsci]
+        fwt = 4096 / 13.56E6 * (2**fwti)
+
+        if fsc > self.clf.max_send_data_size:
+            log.warning("{0} does not support fsc {1}".format(self.clf, fsc))
+            fsc = self.clf.max_send_data_size
+
+        log.debug("max command frame size is {0:d} byte".format(fsc))
+        log.debug("max frame waiting time is {0:f}".format(fwt))
+
+        self._dep = IsoDepInitiator(clf, fsc, fwt)
+        self._extended_length_support = False
+
+
+class Type4BTag(Type4Tag):
+    def __init__(self, clf, target):
+        super(Type4BTag, self).__init__(clf, target)
+        self._nfcid = bytearray(target.sensb_res[1:5])
+
+        log.debug("send ATTRIB command to activate the Type 4B Tag")
+        if self.clf.max_recv_data_size < 256:
+            log.warning("{0} does not support fsd 256".format(self.clf))
+            attrib_cmd = b'\x1D' + self._nfcid + b'\x00\x07\x01\x00'
+        else:
+            attrib_cmd = b'\x1D' + self._nfcid + b'\x00\x08\x01\x00'
+        attrib_res = self.clf.exchange(attrib_cmd, timeout=0.03)
+        log.debug("rcvd ATTRIB response %s", hexlify(attrib_res).decode())
+
+        fsci, fwti = target.sensb_res[10] >> 4, target.sensb_res[11] >> 4
+        if fsci > 8:
+            log.warning("FSCI with RFU value in SENSB_RES")
+            fsci = 8
+        if fwti > 14:
+            log.warning("FWI with RFU value in SENSB_RES")
+            fwti = 4
+
+        fsc = (16, 24, 32, 40, 48, 64, 96, 128, 256)[fsci]
+        fwt = 4096 / 13.56E6 * (2**fwti)
+
+        if fsc > self.clf.max_send_data_size:
+            log.warning("{0} does not support fsc {1}".format(self.clf, fsc))
+            fsc = self.clf.max_send_data_size
+
+        log.debug("max command frame size is {0:d} byte".format(fsc))
+        log.debug("max frame waiting time is {0:f}".format(fwt))
+
+        self._dep = IsoDepInitiator(clf, fsc, fwt)
+        self._extended_length_support = False
+
+
+def activate(clf, target):
+    if target.brty.endswith('A'):
+        return Type4ATag(clf, target)
+    if target.brty.endswith('B'):
+        return Type4BTag(clf, target)

src/test/rfid.py

@@ -8,8 +8,8 @@ from pathlib import Path
 
 import serial
 import ndef
-import nfc
+from src.lib import nfc as nfc
-from nfc.clf import RemoteTarget
+from src.lib.nfc.clf import RemoteTarget
 
 logging.basicConfig(
     format="{asctime}:{name}:{levelname}:{message}",

src/ui/barcode_recipe_selection/barcode_recipe_selection.py

@@ -75,7 +75,7 @@ class Barcode_Recipe_Selection(Test_Test):
         else:
             lines = data.splitlines()
             #lines = data.split("-")
-            candidates = [i for i in lines if len(i) in(10,12)]
+            candidates = [i for i in lines if len(i)in (9,10,12)]
             if len(candidates)>0:
                 # RECIPE CODE FOUND
                 self.recipe=candidates[-1]

src/ui/recipe_selection/recipe_selection.py

@@ -10,6 +10,8 @@ from PyQt5.QtCore import QTimer, pyqtSignal
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtWidgets import QFileDialog, QMessageBox, QShortcut
 import shutil
+
+from lib.helpers.recipe_manager import export_recipes, import_recipes
 from ui.crud import Crud, Json_External_Dialog_Editor_Cell_Widget
 from ui.helpers import replace_widget
 from ui.recipe_spec_and_step_editor import Recipe_Spec_And_Step_Editor
@@ -275,227 +277,22 @@ class Recipe_Selection(Widget):
 
     # IMPORT RECIPES FROM CSV FILE TO DATABASE
     def import_recipes(self, csv_path=None, defaults=None):
-        if defaults is None:
+        import_recipes(
-            global noner
+            config=self.config,
-            defaults = self.config.get("recipes_defaults", noner)
+            csv_path=csv_path,
-        if csv_path is None:
+            defaults=defaults,
-            options = QFileDialog.Options()
+            unsupported_steps=self.unsupported_steps,
-            options |= QFileDialog.DontUseNativeDialog
+            logger=self.log,
-            csv_path, _ = QFileDialog.getOpenFileName(
+        )
-                self,
-                "Importazione ricette",
-                "ricette.csv",
-                "CSV data (*.csv);;All Files (*)",
-                options=options,
-            )
-        csv_path = str(csv_path)
-        if not len(csv_path):
-            return
-        self.log.info(f"recipes: importing recipes from {csv_path}")
-        recipe_name_field = self.config.get("recipe", {}).get("recipe_name_field", "codice_ricetta").strip()
-        part_number_field = self.config.get("recipe", {}).get("part_number_field", "part_number").strip()
-        description_field = self.config.get("recipe", {}).get("description_field", "descrizione").strip()
-        barcode_enable_field = self.config.get("recipe", {}).get("barcode_enable_field", "verifica_codice_a_barre_abilitata").strip()
-
-        with open(csv_path, "r", encoding="utf-8-sig") as f:
-            reader = csv.DictReader(f)
-            count = 0
-            for ucrow in reader:
-                row = dict((k.lower(), v) for k, v in ucrow.items())
-                recipe_name = row.get(recipe_name_field, defaults["codice_ricetta"])
-                steps_specs = self.read_steps(row, defaults=defaults)
-
-                # create recipe or update existing one in DB
-                try:
-                    recipe = Recipes.get_by_id(recipe_name)
-                    steps = recipe.get_steps_map()
-                    recipe_is_new = False
-                except Recipes.DoesNotExist:
-                    recipe = Recipes(name=recipe_name, part_number="TEMPORARY")
-                    steps = {}
-                    for step_name, step_spec in steps_specs.items():
-                        if step_name not in self.unsupported_steps:
-                            steps[step_name] = step_spec
-                    recipe_is_new = True
-                recipe.client = row.get("cliente", defaults["cliente"])
-                recipe.part_number = row.get(part_number_field, defaults["part_number"])
-                recipe.description = row.get(description_field, defaults["descrizione"])
-                recipe.spec = {
-                    "count": len(row.get("dimensione_lotto_abilitata", defaults["dimensione_lotto_abilitata"])) and "count" not in self.unsupported_steps,
-                    "connector": len(
-                        row.get("verifica_connettore_abilitata", defaults["verifica_connettore_abilitata"])) and "connector" not in self.unsupported_steps,
-                    "barcodes": len(row.get(barcode_enable_field, defaults["verifica_codice_a_barre_abilitata"])) and "barcodes" not in self.unsupported_steps,
-                    "resistance": len(row.get("verifica_resistenza_connettore_abilitata",
-                                              defaults["verifica_resistenza_connettore_abilitata"])) and "resistance" not in self.unsupported_steps,
-                    "screws": len(row.get("avvitatura_abilitata", defaults["avvitatura_abilitata"])) and "screws" not in self.unsupported_steps,
-                    "instruction": len(row.get("istruzione_abilitata", defaults["istruzione_abilitata"])) and "instruction" not in self.unsupported_steps,
-                    "instruction_extra": len(row.get("istruzione_abilitata_extra", defaults["istruzione_abilitata_extra"])) and "instruction_extra" not in self.unsupported_steps,
-                    "leak_1": len(row.get("prova_tenuta_abilitata", defaults["prova_tenuta_abilitata"])) and "leak_1" not in self.unsupported_steps,
-                    "leak_2": len(row.get("prova_tenuta_abilitata_2", defaults["prova_tenuta_abilitata_2"])) and "leak_2" not in self.unsupported_steps,
-                    "vision": len(row.get("test_visione_abilitato", defaults["test_visione_abilitato"])) and "vision" not in self.unsupported_steps,
-                    "print": len(row.get("stampa_etichetta_abilitata", defaults["stampa_etichetta_abilitata"])) and "print" not in self.unsupported_steps,
-                    "steps": steps,
-                }
-                recipe.spec["steps"]=steps_specs
-                if recipe_is_new:
-                    recipe.save(force_insert=True)
-                else:
-                    recipe.save()
-                count += 1
-            db.commit()
-            self.log.info(f"recipes: imported {count} rows.")
-            self.crud.refresh()
 
     # EXPORT RECIPES TABLE TO CSV FILE
     def export_recipes(self, csv_path=None):
-        if csv_path is None:
+        export_recipes(
-            options = QFileDialog.Options()
+            config=self.config,
-            options |= QFileDialog.DontUseNativeDialog
+            csv_path=csv_path,
-            csv_path, _ = QFileDialog.getSaveFileName(
+            logger=self.log,
-                self,
+        )
-                "Esportazione ricette",
-                "ricette.csv",
-                "CSV data (*.csv);;All Files (*)",
-                options=options,
-            )
-        csv_path = str(csv_path)
-        if not len(csv_path):
-            return
-        if not csv_path.lower().endswith(".csv"):
-            csv_path += ".csv"
-        csv_dir = os.path.dirname(csv_path)
-        if len(csv_dir):
-            os.makedirs(csv_dir, exist_ok=True)
-        recipe_name_field = self.config.get("recipe", {}).get("recipe_name_field", "codice_ricetta").strip()
-        barcode_enable_field = self.config.get("recipe", {}).get("barcode_enable_field", "verifica_codice_a_barre_abilitata").strip()
-        barcode_serial_field = self.config.get("recipe", {}).get("barcode_serial_field", "codice_a_barre").strip()
-        print_template_field = self.config.get("recipe", {}).get("label_template_field", "modello_etichetta").strip()
-        data = []
-        fieldnames = set()  # Use a set to avoid duplicates
-        for recipe in list(Recipes.select()):
-            steps = recipe.get_steps_map()
-            exportable = {
-                # BASE SECTION
-                recipe_name_field: recipe.name,
-                "cliente": recipe.client,
-                "part_number": recipe.part_number,
-            }
 
-            # Add base fields to the fieldnames
-            fieldnames.update([recipe_name_field, "cliente", "part_number"])
-
-            # Check and add fields conditionally for each section
-            if "connector" in steps:
-                exportable.update({
-                    "verifica_connettore_abilitata": "x",
-                    "connettore": steps["connector"].spec["connector"]
-                })
-                fieldnames.update(["verifica_connettore_abilitata", "connettore"])
-
-            if "resistance" in steps:
-                exportable.update({
-                    "verifica_resistenza_connettore_abilitata": "x",
-                    "scala_resistenza": steps["resistance"].spec["scale"],
-                    "r nominale": steps["resistance"].spec["expected"],
-                    "tolleranza_resistenza_pos": steps["resistance"].spec["tolerance_pos"],
-                    "tolleranza_resistenza_neg": steps["resistance"].spec["tolerance_neg"]
-                })
-                fieldnames.update(["verifica_resistenza_connettore_abilitata", "scala_resistenza", "r nominale",
-                                   "tolleranza_resistenza_pos", "tolleranza_resistenza_neg"])
-
-            if "barcodes" in steps:
-                exportable.update({
-                    barcode_enable_field: "x",
-                    barcode_serial_field: steps["barcodes"].spec["serial"]
-                })
-                fieldnames.update([barcode_enable_field, barcode_serial_field])
-
-            if recipe.spec.get("steps", {}).get("screws") and "screws" in steps:
-                exportable.update({
-                    "avvitatura_abilitata": "x",
-                    "viti": steps["screws"].spec["quantity"]
-                })
-                fieldnames.update(["avvitatura_abilitata", "viti"])
-
-            if "leak_1" in steps:
-                exportable.update({
-                    "prova_tenuta_abilitata": "x",
-                    "tempo_pre_riempimento": steps["leak_1"].spec["pre_filling_time"],
-                    "pressione_pre_riempimento": steps["leak_1"].spec["pre_filling_pressure"],
-                    "tempo_riempimento": steps["leak_1"].spec["filling_time"],
-                    "tempo_assestamento": steps["leak_1"].spec["settling_time"],
-                    "percentuale_minima_pressione_assestamento": steps["leak_1"].spec["settling_pressure_min_percent"],
-                    "percentuale_massima_pressione_assestamento": steps["leak_1"].spec["settling_pressure_max_percent"],
-                    "tempo_di_test": steps["leak_1"].spec["test_time"],
-                    "pressione_di_test_delta_minimo": steps["leak_1"].spec["test_pressure_qneg"],
-                    "pressione_di_test": steps["leak_1"].spec["test_pressure"],
-                    "pressione_di_test_delta_massimo": steps["leak_1"].spec["test_pressure_qpos"],
-                    "tempo_svuotamento": steps["leak_1"].spec["flush_time"],
-                    "pressione_svuotamento": steps["leak_1"].spec["flush_pressure"],
-                })
-                fieldnames.update(["prova_tenuta_abilitata", "tempo_pre_riempimento", "pressione_pre_riempimento",
-                                   "tempo_riempimento", "tempo_assestamento",
-                                   "percentuale_minima_pressione_assestamento",
-                                   "percentuale_massima_pressione_assestamento", "tempo_di_test",
-                                   "pressione_di_test_delta_minimo",
-                                   "pressione_di_test", "pressione_di_test_delta_massimo", "tempo_svuotamento",
-                                   "pressione_svuotamento"])
-
-            if "leak_2" in steps:
-                exportable.update({
-                    "prova_tenuta_abilitata_2": "x",
-                    "tempo_pre_riempimento_2": steps["leak_2"].spec["pre_filling_time"],
-                    "pressione_pre_riempimento_2": steps["leak_2"].spec["pre_filling_pressure"],
-                    "tempo_riempimento_2": steps["leak_2"].spec["filling_time"],
-                    "tempo_assestamento_2": steps["leak_2"].spec["settling_time"],
-                    "percentuale_minima_pressione_assestamento_2": steps["leak_2"].spec[
-                        "settling_pressure_min_percent"],
-                    "percentuale_massima_pressione_assestamento_2": steps["leak_2"].spec[
-                        "settling_pressure_max_percent"],
-                    "tempo_di_test_2": steps["leak_2"].spec["test_time"],
-                    "pressione_di_test_delta_minimo_2": steps["leak_2"].spec["test_pressure_qneg"],
-                    "pressione_di_test_2": steps["leak_2"].spec["test_pressure"],
-                    "pressione_di_test_delta_massimo_2": steps["leak_2"].spec["test_pressure_qpos"],
-                    "tempo_svuotamento_2": steps["leak_2"].spec["flush_time"],
-                    "pressione_svuotamento_2": steps["leak_2"].spec["flush_pressure"],
-                })
-                fieldnames.update(["prova_tenuta_abilitata_2", "tempo_pre_riempimento_2", "pressione_pre_riempimento_2",
-                                   "tempo_riempimento_2", "tempo_assestamento_2",
-                                   "percentuale_minima_pressione_assestamento_2",
-                                   "percentuale_massima_pressione_assestamento_2", "tempo_di_test_2",
-                                   "pressione_di_test_delta_minimo_2", "pressione_di_test_2",
-                                   "pressione_di_test_delta_massimo_2",
-                                   "tempo_svuotamento_2", "pressione_svuotamento_2"])
-
-            if "vision" in steps:
-                exportable.update({
-                    "test_visione_abilitato": recipe.spec["vision"],
-                    "ricetta_visione": steps["vision"].spec["recipe"]
-                })
-                fieldnames.update(["test_visione_abilitato", "ricetta_visione"])
-
-            if "print" in steps:
-                exportable.update({
-                    "stampa_etichetta_abilitata": "x",
-                    print_template_field: steps["print"].spec["template"],
-                    "etichette_supplementari": steps["print"].spec["extra_label"]
-                })
-                fieldnames.update(["stampa_etichetta_abilitata", print_template_field, "etichette_supplementari"])
-
-            # Append the exportable dictionary to the data list
-            data.append(exportable)
-
-        # Convert the set to a list for CSV writing
-        fieldnames = list(fieldnames)
-
-        # Export to CSV if there is data
-        if len(data):
-            self.log.info(f"recipes: exporting recipes to {csv_path}")
-            with open(csv_path, "w", newline="") as f:
-                w = csv.DictWriter(f, fieldnames=fieldnames, extrasaction="ignore")
-                w.writeheader()
-                w.writerows(data)
-            self.log.info(f"recipes: exported {len(data)} rows.")
     def delete_recipes(self):
         ret = QMessageBox.warning(
             None,
@@ -507,40 +304,6 @@ class Recipe_Selection(Widget):
         if ret == QMessageBox.Ok:
             Recipes.delete().execute()
             self.crud.refresh()
-    def backup_current_recipes(self):
-        # Define the backup directory and file name
-        backup_dir = os.path.join('config', 'csv_import', 'backup_csv')
-        timestamp = datetime.now().strftime("%d%m%y%H%M%S")
-        backup_file = f"backup_{timestamp}.csv"
-        backup_path = os.path.join(backup_dir, backup_file)
 
-        # Ensure the backup directory exists
-        os.makedirs(backup_dir, exist_ok=True)
 
-        # Export current recipes to backup file
-        self.export_recipes(csv_path=backup_path)
 
-    def move_imported_csv(self, csv_path):
-        # Move the imported CSV to the 'imported_csv' directory
-        imported_dir = os.path.join('config', 'csv_import', 'imported_csv')
-        os.makedirs(imported_dir, exist_ok=True)
-        imported_path = os.path.join(imported_dir, os.path.basename(csv_path))
-        shutil.move(csv_path, imported_path)
-        self.log.info(f"Imported CSV moved to {imported_path}")
-        return imported_path
-
-    def check_and_import_auto_csv(self):
-            # Define the directory to check
-            auto_import_dir = os.path.join('config', 'csv_import', 'auto_csv_import')
-
-            # Check if the directory exists and is not empty
-            if os.path.exists(auto_import_dir) and os.listdir(auto_import_dir):
-                # Perform backup
-                self.backup_current_recipes()
-
-                # Move and import each CSV file in the directory
-                for csv_file in os.listdir(auto_import_dir):
-                    csv_path = os.path.join(auto_import_dir, csv_file)
-                    if os.path.isfile(csv_path) and csv_file.endswith(".csv"):
-                        self.import_recipes(csv_path=csv_path)
-                        self.move_imported_csv(csv_path)