libosdp 2.4.0__tar.gz

libosdp-2.4.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: libosdp
+Version: 2.4.0
+Summary: Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)
+Home-page: https://github.com/goToMain/libosdp
+Author: Siddharth Chandrasekaran
+Author-email: sidcha.dev@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Python3 Bindings for LibOSDP
+
+This is an initial effort at enabling python3 support for LibOSDP. This document
+assumes that you are already familiar with [LibOSDP API][1] and device life
+cycle management.
+
+## Build/Install
+
+A python module `osdp` and classes `ControlPanel` and `PeripheralDevice` are
+made available when the sources of this directory is built and installed.
+
+After cloning this repo (with `--recurse-submodules`), you can do the following
+(from the repo root) to build the python module.
+
+```bash
+mkdir build && cd build
+cmake ..
+make python
+make python_install
+```
+
+If you want to undo this install, you can run `make python_uninstall`.
+
+## How to use this module?
+
+### Control Panel Mode
+
+```python
+import osdp
+
+## Master key for secure channel
+key = '01020304050607080910111213141516'
+
+## populate osdp_pd_info_t from python
+pd_info = [
+    {
+        "address": 101,
+        "channel_type": "uart",
+        "channel_speed": 115200,
+        "channel_device": '/dev/ttyUSB0',
+    },
+    {
+        "address": 102,
+        "channel_type": "uart",
+        "channel_speed": 115200,
+        "channel_device": '/dev/ttyUSB1',
+    }
+]
+
+## Setup OSDP device in Control Panel mode
+cp = osdp.ControlPanel(pd_info, master_key=key)
+
+## call this refresh method once every 50ms
+cp.refresh()
+
+## create and output command
+output_cmd = {
+    "command": osdp.CMD_OUTPUT,
+    "output_no": 0,
+    "control_code": 1,
+    "timer_count": 10
+}
+
+## send a output command to PD-1
+cp.send_command(1, output_cmd)
+```
+
+see [samples/cp_app.py][2] for more details.
+
+### Peripheral Device mode:
+
+```python
+## Describe the PD
+pd_info = {
+    "address": 101,
+    "channel_type": "uart",
+    "channel_speed": 115200,
+    "channel_device": '/dev/ttyUSB0',
+
+    "version": 1,
+    "model": 1,
+    "vendor_code": 0xCAFEBABE,
+    "serial_number": 0xDEADBEAF,
+    "firmware_version": 0x0000F00D
+}
+
+## Indicate the PD's capabilities to LibOSDP.
+pd_cap = [
+    {
+        # PD is capable of handling output commands
+        "function_code": osdp.CAP_OUTPUT_CONTROL,
+        "compliance_level": 1,
+        "num_items": 1
+    },
+]
+
+## Setup OSDP device in Peripheral Device mode
+pd = osdp.PeripheralDevice(pd_info, capabilities=pd_cap)
+
+## call this refresh method periodically (at lease once every 50ms)
+pd.refresh()
+
+## Define a callback handler. Must return 0 on success, -ve on failures.
+def handle_command(address, command):
+    if address != pd_info['address']:
+        return { "return_code": -1 }
+    print("PD received command: ", command)
+    return { "return_code": 0 }
+
+## Set a handler for incoming commands from CP
+pd.set_command_callback(handle_command)
+```
+
+see [samples/pd_app.py][3] for more details.
+
+[1]: https://libosdp.sidcha.dev/api/
+[2]: https://github.com/goToMain/libosdp/blob/master/samples/python/cp_app.py
+[3]: https://github.com/goToMain/libosdp/blob/master/samples/python/pd_app.py

libosdp-2.4.0/README.md

@@ -0,0 +1,118 @@
+# Python3 Bindings for LibOSDP
+
+This is an initial effort at enabling python3 support for LibOSDP. This document
+assumes that you are already familiar with [LibOSDP API][1] and device life
+cycle management.
+
+## Build/Install
+
+A python module `osdp` and classes `ControlPanel` and `PeripheralDevice` are
+made available when the sources of this directory is built and installed.
+
+After cloning this repo (with `--recurse-submodules`), you can do the following
+(from the repo root) to build the python module.
+
+```bash
+mkdir build && cd build
+cmake ..
+make python
+make python_install
+```
+
+If you want to undo this install, you can run `make python_uninstall`.
+
+## How to use this module?
+
+### Control Panel Mode
+
+```python
+import osdp
+
+## Master key for secure channel
+key = '01020304050607080910111213141516'
+
+## populate osdp_pd_info_t from python
+pd_info = [
+    {
+        "address": 101,
+        "channel_type": "uart",
+        "channel_speed": 115200,
+        "channel_device": '/dev/ttyUSB0',
+    },
+    {
+        "address": 102,
+        "channel_type": "uart",
+        "channel_speed": 115200,
+        "channel_device": '/dev/ttyUSB1',
+    }
+]
+
+## Setup OSDP device in Control Panel mode
+cp = osdp.ControlPanel(pd_info, master_key=key)
+
+## call this refresh method once every 50ms
+cp.refresh()
+
+## create and output command
+output_cmd = {
+    "command": osdp.CMD_OUTPUT,
+    "output_no": 0,
+    "control_code": 1,
+    "timer_count": 10
+}
+
+## send a output command to PD-1
+cp.send_command(1, output_cmd)
+```
+
+see [samples/cp_app.py][2] for more details.
+
+### Peripheral Device mode:
+
+```python
+## Describe the PD
+pd_info = {
+    "address": 101,
+    "channel_type": "uart",
+    "channel_speed": 115200,
+    "channel_device": '/dev/ttyUSB0',
+
+    "version": 1,
+    "model": 1,
+    "vendor_code": 0xCAFEBABE,
+    "serial_number": 0xDEADBEAF,
+    "firmware_version": 0x0000F00D
+}
+
+## Indicate the PD's capabilities to LibOSDP.
+pd_cap = [
+    {
+        # PD is capable of handling output commands
+        "function_code": osdp.CAP_OUTPUT_CONTROL,
+        "compliance_level": 1,
+        "num_items": 1
+    },
+]
+
+## Setup OSDP device in Peripheral Device mode
+pd = osdp.PeripheralDevice(pd_info, capabilities=pd_cap)
+
+## call this refresh method periodically (at lease once every 50ms)
+pd.refresh()
+
+## Define a callback handler. Must return 0 on success, -ve on failures.
+def handle_command(address, command):
+    if address != pd_info['address']:
+        return { "return_code": -1 }
+    print("PD received command: ", command)
+    return { "return_code": 0 }
+
+## Set a handler for incoming commands from CP
+pd.set_command_callback(handle_command)
+```
+
+see [samples/pd_app.py][3] for more details.
+
+[1]: https://libosdp.sidcha.dev/api/
+[2]: https://github.com/goToMain/libosdp/blob/master/samples/python/cp_app.py
+[3]: https://github.com/goToMain/libosdp/blob/master/samples/python/pd_app.py

libosdp-2.4.0/libosdp.egg-info/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: libosdp
+Version: 2.4.0
+Summary: Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)
+Home-page: https://github.com/goToMain/libosdp
+Author: Siddharth Chandrasekaran
+Author-email: sidcha.dev@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Python3 Bindings for LibOSDP
+
+This is an initial effort at enabling python3 support for LibOSDP. This document
+assumes that you are already familiar with [LibOSDP API][1] and device life
+cycle management.
+
+## Build/Install
+
+A python module `osdp` and classes `ControlPanel` and `PeripheralDevice` are
+made available when the sources of this directory is built and installed.
+
+After cloning this repo (with `--recurse-submodules`), you can do the following
+(from the repo root) to build the python module.
+
+```bash
+mkdir build && cd build
+cmake ..
+make python
+make python_install
+```
+
+If you want to undo this install, you can run `make python_uninstall`.
+
+## How to use this module?
+
+### Control Panel Mode
+
+```python
+import osdp
+
+## Master key for secure channel
+key = '01020304050607080910111213141516'
+
+## populate osdp_pd_info_t from python
+pd_info = [
+    {
+        "address": 101,
+        "channel_type": "uart",
+        "channel_speed": 115200,
+        "channel_device": '/dev/ttyUSB0',
+    },
+    {
+        "address": 102,
+        "channel_type": "uart",
+        "channel_speed": 115200,
+        "channel_device": '/dev/ttyUSB1',
+    }
+]
+
+## Setup OSDP device in Control Panel mode
+cp = osdp.ControlPanel(pd_info, master_key=key)
+
+## call this refresh method once every 50ms
+cp.refresh()
+
+## create and output command
+output_cmd = {
+    "command": osdp.CMD_OUTPUT,
+    "output_no": 0,
+    "control_code": 1,
+    "timer_count": 10
+}
+
+## send a output command to PD-1
+cp.send_command(1, output_cmd)
+```
+
+see [samples/cp_app.py][2] for more details.
+
+### Peripheral Device mode:
+
+```python
+## Describe the PD
+pd_info = {
+    "address": 101,
+    "channel_type": "uart",
+    "channel_speed": 115200,
+    "channel_device": '/dev/ttyUSB0',
+
+    "version": 1,
+    "model": 1,
+    "vendor_code": 0xCAFEBABE,
+    "serial_number": 0xDEADBEAF,
+    "firmware_version": 0x0000F00D
+}
+
+## Indicate the PD's capabilities to LibOSDP.
+pd_cap = [
+    {
+        # PD is capable of handling output commands
+        "function_code": osdp.CAP_OUTPUT_CONTROL,
+        "compliance_level": 1,
+        "num_items": 1
+    },
+]
+
+## Setup OSDP device in Peripheral Device mode
+pd = osdp.PeripheralDevice(pd_info, capabilities=pd_cap)
+
+## call this refresh method periodically (at lease once every 50ms)
+pd.refresh()
+
+## Define a callback handler. Must return 0 on success, -ve on failures.
+def handle_command(address, command):
+    if address != pd_info['address']:
+        return { "return_code": -1 }
+    print("PD received command: ", command)
+    return { "return_code": 0 }
+
+## Set a handler for incoming commands from CP
+pd.set_command_callback(handle_command)
+```
+
+see [samples/pd_app.py][3] for more details.
+
+[1]: https://libosdp.sidcha.dev/api/
+[2]: https://github.com/goToMain/libosdp/blob/master/samples/python/cp_app.py
+[3]: https://github.com/goToMain/libosdp/blob/master/samples/python/pd_app.py

libosdp-2.4.0/libosdp.egg-info/SOURCES.txt

@@ -0,0 +1,43 @@
+README.md
+pyproject.toml
+setup.py
+/Users/sidcha/work/osdp/libosdp/python/osdp_sys/base.c
+/Users/sidcha/work/osdp/libosdp/python/osdp_sys/cp.c
+/Users/sidcha/work/osdp/libosdp/python/osdp_sys/data.c
+/Users/sidcha/work/osdp/libosdp/python/osdp_sys/module.c
+/Users/sidcha/work/osdp/libosdp/python/osdp_sys/pd.c
+/Users/sidcha/work/osdp/libosdp/python/osdp_sys/utils.c
+/Users/sidcha/work/osdp/libosdp/src/osdp_common.c
+/Users/sidcha/work/osdp/libosdp/src/osdp_cp.c
+/Users/sidcha/work/osdp/libosdp/src/osdp_file.c
+/Users/sidcha/work/osdp/libosdp/src/osdp_pd.c
+/Users/sidcha/work/osdp/libosdp/src/osdp_phy.c
+/Users/sidcha/work/osdp/libosdp/src/osdp_sc.c
+/Users/sidcha/work/osdp/libosdp/src/crypto/tinyaes.c
+/Users/sidcha/work/osdp/libosdp/src/crypto/tinyaes_src.c
+/Users/sidcha/work/osdp/libosdp/utils/src/bus_server.c
+/Users/sidcha/work/osdp/libosdp/utils/src/channel.c
+/Users/sidcha/work/osdp/libosdp/utils/src/disjoint_set.c
+/Users/sidcha/work/osdp/libosdp/utils/src/event.c
+/Users/sidcha/work/osdp/libosdp/utils/src/fdutils.c
+/Users/sidcha/work/osdp/libosdp/utils/src/hashmap.c
+/Users/sidcha/work/osdp/libosdp/utils/src/list.c
+/Users/sidcha/work/osdp/libosdp/utils/src/logger.c
+/Users/sidcha/work/osdp/libosdp/utils/src/memory.c
+/Users/sidcha/work/osdp/libosdp/utils/src/queue.c
+/Users/sidcha/work/osdp/libosdp/utils/src/serial.c
+/Users/sidcha/work/osdp/libosdp/utils/src/slab.c
+/Users/sidcha/work/osdp/libosdp/utils/src/sockutils.c
+/Users/sidcha/work/osdp/libosdp/utils/src/strutils.c
+/Users/sidcha/work/osdp/libosdp/utils/src/utils.c
+/Users/sidcha/work/osdp/libosdp/utils/src/workqueue.c
+libosdp.egg-info/PKG-INFO
+libosdp.egg-info/SOURCES.txt
+libosdp.egg-info/dependency_links.txt
+libosdp.egg-info/top_level.txt
+osdp/__init__.py
+osdp/constants.py
+osdp/control_panel.py
+osdp/helpers.py
+osdp/key_store.py
+osdp/peripheral_device.py

libosdp-2.4.0/libosdp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

libosdp-2.4.0/libosdp.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+osdp
+osdp_sys

libosdp-2.4.0/osdp/__init__.py

@@ -0,0 +1,18 @@
+#
+#  Copyright (c) 2021-2023 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#
+#  SPDX-License-Identifier: Apache-2.0
+#
+
+from .control_panel import ControlPanel
+from .peripheral_device import PeripheralDevice
+from .key_store import KeyStore
+from .constants import (
+    LibFlag, Command, CommandLEDColor, CommandFileTxFlags,
+    Event, CardFormat, Capability, LogLevel
+)
+from .helpers import PDInfo, PDCapabilities
+
+__author__ = 'Siddharth Chandrasekaran <sidcha.dev@gmail.com>'
+__copyright__ = 'Copyright 2021-2023 Siddharth Chandrasekaran'
+__license__ = 'Apache License, Version 2.0 (Apache-2.0)'

libosdp-2.4.0/osdp/constants.py

@@ -0,0 +1,71 @@
+#
+#  Copyright (c) 2021-2023 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#
+#  SPDX-License-Identifier: Apache-2.0
+#
+
+import osdp_sys
+
+class LibFlag:
+    EnforceSecure = osdp_sys.FLAG_ENFORCE_SECURE
+    InstallMode = osdp_sys.FLAG_INSTALL_MODE
+    IgnoreUnsolicited = osdp_sys.FLAG_IGN_UNSOLICITED
+
+class LogLevel:
+    Emergency = osdp_sys.LOG_EMERG
+    Alert = osdp_sys.LOG_ALERT
+    Critical = osdp_sys.LOG_CRIT
+    Error = osdp_sys.LOG_ERROR
+    Warning = osdp_sys.LOG_WARNING
+    Notice = osdp_sys.LOG_NOTICE
+    Info = osdp_sys.LOG_INFO
+    Debug = osdp_sys.LOG_DEBUG
+
+class Command:
+    Output = osdp_sys.CMD_OUTPUT
+    Buzzer = osdp_sys.CMD_BUZZER
+    LED = osdp_sys.CMD_LED
+    Comset = osdp_sys.CMD_COMSET
+    Text = osdp_sys.CMD_TEXT
+    Manufacturer = osdp_sys.CMD_MFG
+    Keyset = osdp_sys.CMD_KEYSET
+    FileTransfer = osdp_sys.CMD_FILE_TX
+
+class CommandLEDColor:
+    Black = osdp_sys.LED_COLOR_NONE
+    Red = osdp_sys.LED_COLOR_RED
+    Green = osdp_sys.LED_COLOR_GREEN
+    Amber = osdp_sys.LED_COLOR_AMBER
+    Blue = osdp_sys.LED_COLOR_BLUE
+
+class CommandFileTxFlags:
+    Cancel = osdp_sys.CMD_FILE_TX_FLAG_CANCEL
+
+class Event:
+    CardRead = osdp_sys.EVENT_CARDREAD
+    KeyPress = osdp_sys.EVENT_KEYPRESS
+    ManufacturerReply = osdp_sys.EVENT_MFGREP
+    InputOutput = osdp_sys.EVENT_IO
+    Status = osdp_sys.EVENT_STATUS
+
+class CardFormat:
+    Unspecified = osdp_sys.CARD_FMT_RAW_UNSPECIFIED
+    Wiegand = osdp_sys.CARD_FMT_RAW_WIEGAND
+    ASCII = osdp_sys.CARD_FMT_ASCII
+
+class Capability:
+    Unused = osdp_sys.CAP_UNUSED
+    ContactStatusMonitoring = osdp_sys.CAP_CONTACT_STATUS_MONITORING
+    OutputControl = osdp_sys.CAP_OUTPUT_CONTROL
+    CardDataFormat = osdp_sys.CAP_CARD_DATA_FORMAT
+    LEDControl = osdp_sys.CAP_READER_LED_CONTROL
+    AudibleControl = osdp_sys.CAP_READER_AUDIBLE_OUTPUT
+    TextOutput = osdp_sys.CAP_READER_TEXT_OUTPUT
+    TimeKeeping = osdp_sys.CAP_TIME_KEEPING
+    CheckCharacter = osdp_sys.CAP_CHECK_CHARACTER_SUPPORT
+    CommunicationSecurity = osdp_sys.CAP_COMMUNICATION_SECURITY
+    ReceiveBufferSize = osdp_sys.CAP_RECEIVE_BUFFERSIZE
+    CombinedMessageSize = osdp_sys.CAP_LARGEST_COMBINED_MESSAGE_SIZE
+    SmartCard = osdp_sys.CAP_SMART_CARD_SUPPORT
+    Readers = osdp_sys.CAP_READERS
+    Biometrics = osdp_sys.CAP_BIOMETRICS

libosdp-2.4.0/osdp/control_panel.py

@@ -0,0 +1,193 @@
+#
+#  Copyright (c) 2021-2023 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#
+#  SPDX-License-Identifier: Apache-2.0
+#
+import sys
+import os
+import tempfile
+import osdp_sys
+import time
+import queue
+import threading
+
+from .helpers import PDInfo
+from .constants import LibFlag, LogLevel
+
+class ControlPanel():
+    def __init__(self, pd_info_list, log_level: LogLevel=LogLevel.Info,
+                 master_key: bytes=None):
+        self.pd_addr = []
+        info_list = []
+        self.num_pds = len(pd_info_list)
+        for pd_info in pd_info_list:
+            self.pd_addr.append(pd_info.address)
+            info_list.append(pd_info.get())
+        self.event_queue = [ queue.Queue() for i in self.pd_addr ]
+        if master_key:
+            self.ctx = osdp_sys.ControlPanel(info_list, master_key=master_key)
+        else:
+            self.ctx = osdp_sys.ControlPanel(info_list)
+        self.ctx.set_event_callback(self.event_handler)
+        self.ctx.set_loglevel(log_level)
+        self.event = None
+        self.lock = None
+        self.thread = None
+
+    @staticmethod
+    def refresh(event, lock, ctx):
+        while not event.is_set():
+            lock.acquire()
+            ctx.refresh()
+            lock.release()
+            time.sleep(0.020) #sleep for 20ms
+
+    def event_handler(self, pd, event):
+        self.event_queue[pd].put(event)
+
+    def get_event(self, address, timeout: int=5):
+        pd = self.pd_addr.index(address)
+        try:
+            event = self.event_queue[pd].get(timeout=timeout)
+        except queue.Empty:
+            return None
+        return event
+
+    def status(self):
+        self.lock.acquire()
+        bitmask = self.ctx.status()
+        self.lock.release()
+        return bitmask
+
+    def is_online(self, address):
+        pd = self.pd_addr.index(address)
+        return bool(self.status() & (1 << pd))
+
+    def get_num_online(self):
+        online = 0
+        bitmask = self.status()
+        for i in range(len(self.pd_addr)):
+            if bitmask & (1 << i):
+                online += 1
+        return online
+
+    def sc_status(self):
+        self.lock.acquire()
+        bitmask = self.ctx.sc_status()
+        self.lock.release()
+        return bitmask
+
+    def is_sc_active(self, address):
+        pd = self.pd_addr.index(address)
+        return bool(self.sc_status() & (1 << pd))
+
+    def get_num_sc_active(self):
+        sc_active = 0
+        bitmask = self.sc_status()
+        for i in range(len(self.pd_addr)):
+            if bitmask & (1 << i):
+                sc_active += 1
+        return sc_active
+
+    def send_command(self, address, cmd):
+        pd = self.pd_addr.index(address)
+        self.lock.acquire()
+        ret = self.ctx.send_command(pd, cmd)
+        self.lock.release()
+        return ret
+
+    def set_flag(self, address, flag: LibFlag):
+        pd = self.pd_addr.index(address)
+        self.lock.acquire()
+        ret = self.ctx.set_flag(pd, flag)
+        self.lock.release()
+        return ret
+
+    def clear_flag(self, address, flag: LibFlag):
+        pd = self.pd_addr.index(address)
+        self.lock.acquire()
+        ret = self.ctx.clear_flag(pd, flag)
+        self.lock.release()
+        return ret
+
+    def register_file_ops(self, address, fops):
+        pd = self.pd_addr.index(address)
+        self.lock.acquire()
+        ret = self.ctx.register_file_ops(pd, fops)
+        self.lock.release()
+        return ret
+
+    def get_file_tx_status(self, address):
+        pd = self.pd_addr.index(address)
+        self.lock.acquire()
+        ret = self.ctx.get_file_tx_status(pd)
+        self.lock.release()
+        return ret
+
+    def start(self):
+        if self.thread:
+            raise RuntimeError("Thread already running!")
+        self.event = threading.Event()
+        self.lock = threading.Lock()
+        args=(self.event, self.lock, self.ctx)
+        self.thread = threading.Thread(name='cp', target=self.refresh, args=args)
+        self.thread.start()
+
+    def stop(self):
+        if not self.thread:
+            raise RuntimeError("Thread not running!")
+        while self.thread.is_alive():
+            self.event.set()
+            self.thread.join(2)
+            if not self.thread.is_alive():
+                self.thread = None
+                break
+
+    def online_wait_all(self, timeout=10):
+        count = 0
+        res = False
+        while count < timeout * 2:
+            time.sleep(0.5)
+            if self.get_num_online() == len(self.pd_addr):
+                res = True
+                break
+            count += 1
+        return res
+
+    def online_wait(self, address, timeout=5):
+        count = 0
+        res = False
+        while count < timeout * 2:
+            time.sleep(0.5)
+            if self.is_online(address):
+                res = True
+                break
+            count += 1
+        return res
+
+    def sc_wait(self, address, timeout=5):
+        count = 0
+        res = False
+        while count < timeout * 2:
+            time.sleep(0.5)
+            if self.is_sc_active(address):
+                res = True
+                break
+            count += 1
+        return res
+
+    def sc_wait_all(self, timeout=5):
+        count = 0
+        res = False
+        all_pd_mask = (1 << self.num_pds) - 1
+        while count < timeout * 2:
+            time.sleep(0.5)
+            if self.sc_status() == all_pd_mask:
+                res = True
+                break
+            count += 1
+        return res
+
+    def teardown(self):
+        self.stop()
+        self.ctx = None

libosdp-2.4.0/osdp/helpers.py

@@ -0,0 +1,78 @@
+#
+#  Copyright (c) 2021-2023 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#
+#  SPDX-License-Identifier: Apache-2.0
+#
+
+import os
+from .constants import Capability, LibFlag
+
+class PDInfo:
+    def __init__(self, address: int, scbk: bytes=None, name: str='chn', flags=[],
+                 channel_type: str='fifo'):
+        self.address = address
+        self.flags = flags
+        self.scbk = scbk
+        self.name = name
+        self.channel_device = '/tmp/pyosdp-' + name
+        self.channel_speed = 115200
+        self.channel_type = channel_type
+        self.version= 1
+        self.model= 1
+        self.vendor_code= 0xCAFEBABE
+        self.serial_number= 0xDEADBEAF
+        self.firmware_version= 0x0000F00D
+
+        if self.channel_type == 'unix_bus' and os.path.exists(self.channel_device):
+            os.remove(self.channel_device)
+
+    def get_flags(self) -> int:
+        ret = 0
+        for flag in self.flags:
+            ret |= flag
+        return ret
+
+    def get(self) -> dict:
+        return {
+            'name': self.name,
+            'address': self.address,
+            'flags': self.get_flags(),
+            'scbk': self.scbk,
+            'channel_type': self.channel_type,
+            'channel_speed': self.channel_speed,
+            'channel_device': self.channel_device,
+
+            # Following are needed only for PD. For CP these are don't cares
+            'version': self.version,
+            'model': self.model,
+            'vendor_code': self.vendor_code,
+            'serial_number': self.serial_number,
+            'firmware_version': self.firmware_version
+        }
+
+class _PDCapEntity:
+    def __init__(self, function_code: Capability,
+                 compliance_level: int=1, num_items: int=1):
+        self.function_code = function_code
+        self.compliance_level = compliance_level
+        self.num_items = num_items
+
+    def get(self) -> dict:
+        return {
+            'function_code': self.function_code,
+            'compliance_level': self.compliance_level,
+            'num_items': self.num_items
+        }
+
+class PDCapabilities:
+    def __init__(self, cap_list=[]):
+        self.capabilities = {}
+        for cap in cap_list:
+            (fc, cl, ni) = cap
+            self.capabilities[fc] = _PDCapEntity(fc, cl, ni)
+
+    def get(self):
+        ret = []
+        for fc in self.capabilities.keys():
+            ret.append(self.capabilities[fc].get())
+        return ret

libosdp-2.4.0/osdp/key_store.py

@@ -0,0 +1,66 @@
+#
+#  Copyright (c) 2021-2023 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#
+#  SPDX-License-Identifier: Apache-2.0
+#
+
+import os
+import tempfile
+import random
+
+class KeyStore():
+    def __init__(self, dir=None):
+        self.temp_dir = None
+        self.keys = {}
+        if not dir:
+            self.temp_dir = tempfile.TemporaryDirectory()
+            self.key_dir = self.temp_dir.name
+        else:
+            self.key_dir = dir
+
+    def key_file(self, name):
+        return os.path.join(self.key_dir, 'key_' + name + '.bin')
+
+    @staticmethod
+    def gen_key(key_len=16):
+        key = []
+        for i in range(key_len):
+            key.append(random.randint(0, 255))
+        return bytes(key)
+
+    def store_key(self, name):
+        if name not in self.keys:
+            raise RuntimeError
+        key = self.keys[name]
+        with open(self.key_file(name), "w") as f:
+            f.write(key.hex())
+
+    def get_key(self, name):
+        if name not in self.keys:
+            raise RuntimeError
+        return self.keys[name]
+
+    def new_key(self, name, key_len=16, force=True):
+        if not force and name in self.keys:
+            raise RuntimeError
+        self.keys[name] = self.gen_key(key_len)
+        return self.keys[name]
+
+    def update_key(self, name, key):
+        if name not in self.keys:
+            raise RuntimeError
+        self.keys[name] = key
+
+    def load_key(self, name, key_len=16):
+        if not os.path.exists(self.key_file(name)):
+            raise RuntimeError
+        with open(self.key_file(name), "r") as f:
+            key = bytes.fromhex(f.read())
+        if not key or not isinstance(key, bytes) or len(key) != key_len:
+            raise RuntimeError
+        self.keys[name] = key
+        return key
+
+    def __del__(self):
+        if self.temp_dir:
+            self.temp_dir.cleanup()

libosdp-2.4.0/osdp/peripheral_device.py

@@ -0,0 +1,85 @@
+#
+#  Copyright (c) 2021-2023 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#
+#  SPDX-License-Identifier: Apache-2.0
+#
+
+import osdp_sys
+import time
+import queue
+import threading
+
+from .helpers import PDInfo, PDCapabilities
+from .constants import LogLevel
+
+class PeripheralDevice():
+    def __init__(self, pd_info: PDInfo, pd_cap: PDCapabilities,
+                 log_level: LogLevel=LogLevel.Info):
+        self.command_queue = queue.Queue()
+        self.address = pd_info.address
+        self.ctx = osdp_sys.PeripheralDevice(pd_info.get(), capabilities=pd_cap.get())
+        self.ctx.set_loglevel(log_level)
+        self.ctx.set_command_callback(self.command_handler)
+        self.event = None
+        self.lock = None
+        self.thread = None
+
+    @staticmethod
+    def refresh(event, lock, ctx):
+        while not event.is_set():
+            lock.acquire()
+            ctx.refresh()
+            lock.release()
+            time.sleep(0.020) #sleep for 20ms
+
+    def command_handler(self, command):
+        self.command_queue.put(command)
+        return { "return_code": 0 }
+
+    def get_command(self, timeout: int=5):
+        try:
+            cmd = self.command_queue.get(timeout=timeout)
+        except queue.Empty:
+            return None
+        return cmd
+
+    def notify_event(self, event):
+        self.lock.acquire()
+        ret = self.ctx.notify_event(event)
+        self.lock.release()
+        return ret
+
+    def register_file_ops(self, fops):
+        self.lock.acquire()
+        ret = self.ctx.register_file_ops(0, fops)
+        self.lock.release()
+        return ret
+
+    def is_sc_active(self):
+        return self.ctx.is_sc_active()
+
+    def is_online(self):
+        return self.ctx.is_online()
+
+    def start(self):
+        if self.thread:
+            raise RuntimeError("Thread already running!")
+        self.event = threading.Event()
+        self.lock = threading.Lock()
+        args = (self.event, self.lock, self.ctx,)
+        self.thread = threading.Thread(name='pd', target=self.refresh, args=args)
+        self.thread.start()
+
+    def stop(self):
+        if not self.thread:
+            raise RuntimeError("Thread not running!")
+        while self.thread.is_alive():
+            self.event.set()
+            self.thread.join(2)
+            if not self.thread.is_alive():
+                self.thread = None
+                break
+
+    def teardown(self):
+        self.stop()
+        self.ctx = None

libosdp-2.4.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools >= 57.2.0"]
+build-backend = "setuptools.build_meta"

libosdp-2.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

libosdp-2.4.0/setup.py

@@ -0,0 +1,203 @@
+#
+#  Copyright (c) 2020-2023 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#
+#  SPDX-License-Identifier: Apache-2.0
+#
+
+import os
+import re
+from setuptools import setup, Extension
+import shutil
+import subprocess
+
+current_dir = os.environ.get("PWD")
+build_dir = os.path.abspath(os.path.join(current_dir, "build"))
+root_dir = os.path.abspath(os.path.join(current_dir, ".."))
+
+def read_version():
+    with open(os.path.join(root_dir, "CMakeLists.txt")) as f:
+        for line in f.readlines():
+            m = re.match(r"^project\((.+) VERSION (\d+\.\d+\.\d+)\)$", line)
+            if (m):
+                return m.groups()
+    raise RuntimeError("Failed to parse package name and version")
+
+project_name, project_version = read_version()
+
+def map_prefix(src_list, path, check_files=False):
+    paths = [ os.path.join(path, src) for src in src_list ]
+    for path in paths:
+        if check_files:
+            if not os.path.exists(path):
+                raise RuntimeError(f"Path '{path}' does not exist")
+    return paths
+
+def exec_cmd(cmd):
+    r = subprocess.run(cmd, capture_output = True, text = True)
+    return r.stdout.strip()
+
+def get_git_info():
+    d = {}
+    d["branch"] = exec_cmd(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+    d["tag"] = exec_cmd([ "git", "describe", "--exact-match", "--tags" ])
+    d["diff"] = exec_cmd([ "git", "diff", "--quiet", "--exit-code" ])
+    d["rev"] = exec_cmd(["git", "log", "--pretty=format:%h", "-n", "1"])
+    d["root"] = exec_cmd(["git", "rev-parse", "--show-toplevel"])
+    return d
+
+def configure_file(file, replacements):
+    with open(file) as f:
+        contents = f.read()
+    pat = re.compile(r"@(\w+)@")
+    for match in pat.findall(contents):
+        if match in replacements:
+            contents = contents.replace(f"@{match}@", replacements[match])
+    with open(file, 'w') as f:
+        f.write(contents)
+
+def generate_osdp_build_headers():
+    os.makedirs(build_dir, exist_ok=True)
+    with open(os.path.join(build_dir, "osdp_export.h"), 'w') as f:
+        f.write("#define OSDP_EXPORT\n")
+
+    git = get_git_info()
+    dest = os.path.join(build_dir, "osdp_config.h")
+    shutil.copy(os.path.join(root_dir, "src/osdp_config.h.in"), dest)
+    configure_file(dest, {
+        "PROJECT_VERSION": project_version,
+        "PROJECT_NAME": project_name,
+        "GIT_BRANCH": git["branch"],
+        "GIT_REV": git["rev"],
+        "GIT_TAG": git["tag"],
+        "GIT_DIFF": git["diff"],
+        "REPO_ROOT": git["root"],
+    })
+
+generate_osdp_build_headers()
+
+utils_sources = map_prefix([
+    "utils/src/list.c",
+    "utils/src/queue.c",
+    "utils/src/slab.c",
+    "utils/src/utils.c",
+    "utils/src/logger.c",
+    "utils/src/disjoint_set.c",
+    "utils/src/serial.c",
+    "utils/src/channel.c",
+    "utils/src/hashmap.c",
+    "utils/src/strutils.c",
+    "utils/src/memory.c",
+    "utils/src/fdutils.c",
+    "utils/src/event.c",
+    "utils/src/workqueue.c",
+    "utils/src/sockutils.c",
+    "utils/src/bus_server.c",
+], root_dir)
+
+lib_sources = map_prefix([
+    "src/osdp_common.c",
+    "src/osdp_phy.c",
+    "src/osdp_sc.c",
+    "src/osdp_file.c",
+    "src/osdp_pd.c",
+    "src/osdp_cp.c",
+    "src/crypto/tinyaes_src.c",
+    "src/crypto/tinyaes.c",
+], root_dir)
+
+osdp_sys_sources = map_prefix([
+    "osdp_sys/module.c",
+    "osdp_sys/base.c",
+    "osdp_sys/cp.c",
+    "osdp_sys/pd.c",
+    "osdp_sys/data.c",
+    "osdp_sys/utils.c",
+], current_dir)
+
+source_files = utils_sources + lib_sources + osdp_sys_sources
+
+include_dirs = map_prefix([
+    "utils/include",
+    "include",
+    "src",
+    "python/build",
+], root_dir)
+
+other_files = map_prefix([
+    "CMakeLists.txt",
+    "src/osdp_config.h.in"
+], root_dir)
+
+include_files = map_prefix([
+    "utils/include/utils/list.h",
+    "utils/include/utils/queue.h",
+    "utils/include/utils/slab.h",
+    "utils/include/utils/utils.h",
+    "utils/include/utils/logger.h",
+    "utils/include/utils/disjoint_set.h",
+    "utils/include/utils/serial.h",
+    "utils/include/utils/channel.h",
+    "utils/include/utils/hashmap.h",
+    "utils/include/utils/strutils.h",
+    "utils/include/utils/memory.h",
+    "utils/include/utils/fdutils.h",
+    "utils/include/utils/event.h",
+    "utils/include/utils/workqueue.h",
+    "utils/include/utils/sockutils.h",
+    "utils/include/utils/bus_server.h",
+    "include/osdp.h",
+    "src/osdp_common.h",
+    "src/osdp_file.h",
+    "python/build/osdp_config.h",
+    "python/build/osdp_export.h",
+], root_dir, check_files=True)
+
+libosdp_includes = [ "-I" + path for path in include_dirs ]
+
+definitions = [
+    # "CONFIG_OSDP_PACKET_TRACE",
+    # "CONFIG_OSDP_DATA_TRACE",
+    # "CONFIG_OSDP_SKIP_MARK_BYTE",
+]
+
+compile_args = (
+    [ "-I" + path for path in include_dirs ] +
+    [ "-D" + define for define in definitions ]
+)
+
+link_args = []
+
+if os.path.exists("README.md"):
+    with open("README.md", "r") as f:
+        long_description = f.read()
+else:
+    long_description = ""
+
+setup(
+    name         = project_name,
+    version      = project_version,
+    author       = "Siddharth Chandrasekaran",
+    author_email = "sidcha.dev@gmail.com",
+    description  = "Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)",
+    url          = "https://github.com/goToMain/libosdp",
+    ext_modules  = [
+        Extension(
+            name               = "osdp_sys",
+            sources            = source_files,
+            extra_compile_args = compile_args,
+            extra_link_args    = link_args,
+            define_macros      = [],
+            language           = "C",
+        )
+    ],
+    packages     = [ "osdp" ],
+    classifiers  = [
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ],
+    long_description              = long_description,
+    long_description_content_type = "text/markdown",
+    python_requires               = ">=3.8",
+    package_data = { project_name : other_files }
+)