libosdp 3.0.6__tar.gz → 3.0.8__tar.gz

{libosdp-3.0.6 → libosdp-3.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libosdp
-Version: 3.0.6
+Version: 3.0.8
 Summary: Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)
 Home-page: https://github.com/goToMain/libosdp
 Author: Siddharth Chandrasekaran

{libosdp-3.0.6 → libosdp-3.0.8}/libosdp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libosdp
-Version: 3.0.6
+Version: 3.0.8
 Summary: Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)
 Home-page: https://github.com/goToMain/libosdp
 Author: Siddharth Chandrasekaran

{libosdp-3.0.6 → libosdp-3.0.8}/libosdp.egg-info/SOURCES.txt

@@ -25,11 +25,11 @@ vendor/src/osdp_common.c
 vendor/src/osdp_common.h
 vendor/src/osdp_config.h
 vendor/src/osdp_cp.c
+vendor/src/osdp_diag.c
+vendor/src/osdp_diag.h
 vendor/src/osdp_export.h
 vendor/src/osdp_file.c
 vendor/src/osdp_file.h
-vendor/src/osdp_pcap.c
-vendor/src/osdp_pcap.h
 vendor/src/osdp_pd.c
 vendor/src/osdp_phy.c
 vendor/src/osdp_sc.c

{libosdp-3.0.6 → libosdp-3.0.8}/osdp/__init__.py

@@ -8,10 +8,10 @@ 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, StatusReportType
+    LibFlag, Command, CommandLEDColor, CommandFileTxFlags, Event, EventNotification,
+    CardFormat, Capability, LogLevel, StatusReportType
 )
-from .helpers import PDInfo, PDCapabilities
+from .helpers import PdId, PDInfo, PDCapabilities
 from .channel import Channel
 
 __author__ = 'Siddharth Chandrasekaran <sidcha.dev@gmail.com>'

{libosdp-3.0.6 → libosdp-3.0.8}/osdp/constants.py

@@ -10,6 +10,9 @@ class LibFlag:
     EnforceSecure = osdp_sys.FLAG_ENFORCE_SECURE
     InstallMode = osdp_sys.FLAG_INSTALL_MODE
     IgnoreUnsolicited = osdp_sys.FLAG_IGN_UNSOLICITED
+    EnableNotification = osdp_sys.FLAG_ENABLE_NOTIFICATION
+    CapturePackets = osdp_sys.FLAG_CAPTURE_PACKETS
+    AllowEmptyEncryptedDataBlock = osdp_sys.FLAG_ALLOW_EMPTY_ENCRYPTED_DATA_BLOCK
 
 class LogLevel:
     Emergency = osdp_sys.LOG_EMERG
@@ -51,11 +54,17 @@ class CommandLEDColor:
 class CommandFileTxFlags:
     Cancel = osdp_sys.CMD_FILE_TX_FLAG_CANCEL
 
+class EventNotification:
+    Command = osdp_sys.EVENT_NOTIFICATION_COMMAND
+    SecureChannelStatus = osdp_sys.EVENT_NOTIFICATION_SC_STATUS
+    PeripheralDeviceStatus = osdp_sys.EVENT_NOTIFICATION_PD_STATUS
+
 class Event:
     CardRead = osdp_sys.EVENT_CARDREAD
     KeyPress = osdp_sys.EVENT_KEYPRESS
     ManufacturerReply = osdp_sys.EVENT_MFGREP
     Status = osdp_sys.EVENT_STATUS
+    Notification = osdp_sys.EVENT_NOTIFICATION
 
 class CardFormat:
     Unspecified = osdp_sys.CARD_FMT_RAW_UNSPECIFIED

{libosdp-3.0.6 → libosdp-3.0.8}/osdp/control_panel.py

@@ -3,17 +3,14 @@
 #
 #  SPDX-License-Identifier: Apache-2.0
 #
-import sys
-import os
-import tempfile
 import osdp_sys
 import time
 import queue
 import threading
-from typing import Callable
+from typing import Callable, Tuple
 
-from .helpers import PDInfo
-from .constants import LibFlag, LogLevel
+from .helpers import PDInfo, PdId
+from .constants import Capability, LibFlag, LogLevel
 
 class ControlPanel():
     def __init__(
@@ -73,6 +70,29 @@ class ControlPanel():
         pd = self.pd_addr.index(address)
         return bool(self.status() & (1 << pd))
 
+    def get_pd_id(self, address: int) -> PdId:
+        pd = self.pd_addr.index(address)
+        self.lock.acquire()
+        pd_id_dict = self.ctx.get_pd_id(pd)
+        self.lock.release()
+        if pd_id_dict:
+            # version: int, model: int, vendor_code: int, serial_number: int, firmware_version: int
+            pd_id = PdId(
+                pd_id_dict['version'],
+                pd_id_dict['model'],
+                pd_id_dict['vendor_code'],
+                pd_id_dict['serial_number'],
+                pd_id_dict['firmware_version']
+            )
+        return pd_id
+
+    def check_capability(self, address: int, cap: Capability) -> Tuple[int, int]:
+        pd = self.pd_addr.index(address)
+        self.lock.acquire()
+        compliance_level, num_items = self.ctx.check_capability(pd, cap)
+        self.lock.release()
+        return (compliance_level, num_items)
+
     def get_num_online(self):
         online = 0
         bitmask = self.status()
@@ -164,7 +184,7 @@ class ControlPanel():
             count += 1
         return res
 
-    def online_wait(self, address, timeout=5):
+    def online_wait(self, address, timeout=8):
         count = 0
         res = False
         while count < timeout * 2:
@@ -175,6 +195,11 @@ class ControlPanel():
             count += 1
         return res
 
+    def offline_wait(self, address, timeout=8):
+        count = 0
+        time.sleep(timeout)
+        return self.is_online(address) == False
+
     def sc_wait(self, address, timeout=5):
         count = 0
         res = False

{libosdp-3.0.6 → libosdp-3.0.8}/osdp/key_store.py

@@ -28,11 +28,8 @@ class KeyStore():
             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:
+    def _store_key(self, key):
+        with open(self.key_file(key), "w") as f:
             f.write(key.hex())
 
     def get_key(self, name):
@@ -46,6 +43,11 @@ class KeyStore():
         self.keys[name] = self.gen_key(key_len)
         return self.keys[name]
 
+    def commit_key(self, name):
+        if name not in self.keys:
+            raise RuntimeError
+        self._store_key(self.keys[name])
+
     def update_key(self, name, key):
         if name not in self.keys:
             raise RuntimeError
@@ -63,4 +65,4 @@ class KeyStore():
 
     def __del__(self):
         if self.temp_dir:
-            self.temp_dir.cleanup()
+            self.temp_dir.cleanup()

{libosdp-3.0.6 → libosdp-3.0.8}/osdp/peripheral_device.py

@@ -74,7 +74,7 @@ class PeripheralDevice():
     def is_online(self):
         return self.ctx.is_online()
 
-    def sc_wait(self, timeout=5):
+    def sc_wait(self, timeout=8):
         count = 0
         res = False
         while count < timeout * 2:

{libosdp-3.0.6 → libosdp-3.0.8}/setup.py

@@ -11,7 +11,7 @@ import shutil
 import subprocess
 
 project_name = "libosdp"
-project_version = "3.0.6"
+project_version = "3.0.8"
 current_dir = os.path.dirname(os.path.realpath(__file__))
 repo_root = os.path.realpath(os.path.join(current_dir, ".."))
 
@@ -132,8 +132,8 @@ other_files = [
     "src/osdp_config.h.in",
 
     # Optional when PACKET_TRACE is enabled
-    "src/osdp_pcap.c",
-    "src/osdp_pcap.h",
+    "src/osdp_diag.c",
+    "src/osdp_diag.h",
     "utils/include/utils/pcap_gen.h",
     "utils/src/pcap_gen.c",
 ]
@@ -147,14 +147,15 @@ try_vendor_sources(
 )
 
 definitions = [
-    # "CONFIG_OSDP_PACKET_TRACE",
+    "CONFIG_OSDP_PACKET_TRACE",
     # "CONFIG_OSDP_DATA_TRACE",
     # "CONFIG_OSDP_SKIP_MARK_BYTE",
 ]
 
-if "CONFIG_OSDP_PACKET_TRACE" in definitions:
+if ("CONFIG_OSDP_PACKET_TRACE" in definitions or
+    "CONFIG_OSDP_DATA_TRACE" in definitions):
     source_files += [
-        "src/osdp_pcap.c",
+        "src/osdp_diag.c",
         "utils/src/pcap_gen.c",
     ]
 

{libosdp-3.0.6 → libosdp-3.0.8}/vendor/include/osdp.h

@@ -52,6 +52,37 @@ extern "C" {
  */
 #define OSDP_FLAG_IGN_UNSOLICITED 0x00040000
 
+/**
+ * @brief Enable LibOSDP notification events - @ref osdp_event_notification - to
+ * be reported using the event callback method registered by the application.
+ *
+ * @note These events, unlike others, are not generated by the PD.
+ *
+ * @note This is a CP mode only flag; in PD mode this flag has no use.
+ */
+#define OSDP_FLAG_ENABLE_NOTIFICATION 0x00080000
+
+/**
+ * @brief Capture raw osdp packets as seen by this device to a pcap file.
+ * LibOSDP must be built with CONFIG_OSDP_PACKET_TRACE or CONFIG_OSDP_DATA_TRACE
+ * for this flag to be in effect.
+ *
+ * @note The app must call osdp_{cp,pd}_teardown() before existing for the
+ * capture file to be finalized and written to the disk.
+ */
+#define OSDP_FLAG_CAPTURE_PACKETS 0x00100000
+
+/**
+ * @brief Allow an empty encrypted data block(SCS_17 and SCS_18 packets).
+ * This is non-conforming to the standard.  If there is no data to be
+ * transferred, the CP should instead use the SCS_15/SCS_16 messages.
+ * Some OSDP implementations are buggy and send a 0-length data block with
+ * the SCS_17 and SCS_18 messages, this flag accepts that buggy behavior.
+ *
+ * @note this is a PD mode only flag
+ */
+#define OSDP_FLAG_ALLOW_EMPTY_ENCRYPTED_DATA_BLOCK 0x00200000
+
 /**
  * @brief Various PD capability function codes.
  */
@@ -365,7 +396,7 @@ enum osdp_status_report_type {
 /**
  * @brief Status report structure. Used by OSDP_CMD_STATUS and
  * OSDP_EVENT_STATUS. In case of command, it is used to send a query to the PD
- * while in the case of events, the PR responds back with this structure.
+ * while in the case of events, the PD responds back with this structure.
  *
  * This can is used by the PD to indicate various status change reports. Upto a
  * maximum of 32 statuses can be reported using this API.
@@ -651,8 +682,8 @@ enum osdp_cmd_e {
 	OSDP_CMD_KEYSET,      /**< Encryption Key Set Command */
 	OSDP_CMD_COMSET,      /**< PD communication configuration command */
 	OSDP_CMD_MFG,         /**< Manufacturer specific command */
-	OSDP_CMD_FILE_TX,     /**< File transfer comand */
-	OSDP_CMD_STATUS,      /**< Status report eommand */
+	OSDP_CMD_FILE_TX,     /**< File transfer command */
+	OSDP_CMD_STATUS,      /**< Status report command */
 	OSDP_CMD_SENTINEL     /**< Max command value */
 };
 
@@ -779,6 +810,49 @@ struct osdp_event_mfgrep {
 	uint8_t data[OSDP_EVENT_MFGREP_MAX_DATALEN];
 };
 
+/**
+ * @brief LibOSDP event notification type
+ */
+enum osdp_event_notification_type {
+	/**
+	 * Application command outcome report.
+	 *
+	 * arg0: The command ID
+	 * arg1: outcome -- 0: success; -1: failure;
+	 */
+	OSDP_EVENT_NOTIFICATION_COMMAND,
+	/**
+	 * Secure Channel state change
+	 *
+	 * arg0: status -- 0: inactive; 1: active
+	 * arg1: scbk type -- 0: scbk; 1: scbk-d
+	 */
+	OSDP_EVENT_NOTIFICATION_SC_STATUS,
+	/**
+	 * PD state change
+	 *
+	 * arg0: status -- 0: offline; 1: online
+	 */
+	OSDP_EVENT_NOTIFICATION_PD_STATUS,
+};
+
+/**
+ * @brief LibOSDP event notification
+ *
+ * These are events generated by LibOSDP for the application to indicate various
+ * status such as external command outcomes, SC state change notifications, etc.
+ * The app can use these events to perform housekeeping activities as needed.
+ *
+ * Each notification event type can use the provided additional data members
+ * @a arg0, @a arg1, ... in custom ways. See @ref osdp_event_notification_type
+ * for documentation on how to use them.
+ */
+struct osdp_event_notification {
+	enum osdp_event_notification_type type;  /**< Notification type */
+	int arg0;                                /**< Additional data member */
+	int arg1;                                /**< Additional data member */
+};
+
 /**
  * @brief OSDP PD Events
  */
@@ -787,6 +861,7 @@ enum osdp_event_type {
 	OSDP_EVENT_KEYPRESS,      /**< Keypad press event */
 	OSDP_EVENT_MFGREP,        /**< Manufacturer specific reply event */
 	OSDP_EVENT_STATUS,        /**< Status event */
+	OSDP_EVENT_NOTIFICATION,  /**< LibOSDP notification event */
 	OSDP_EVENT_SENTINEL       /**< Max event value */
 };
 
@@ -802,8 +877,9 @@ struct osdp_event {
 	union {
 		struct osdp_event_keypress keypress; /**< Keypress event structure */
 		struct osdp_event_cardread cardread; /**< Card read event structure */
-		struct osdp_event_mfgrep mfgrep;     /**< Manufacturer spefific response event struture */
-		struct osdp_status_report status;    /**< Status report event strcture */
+		struct osdp_event_mfgrep mfgrep;     /**< Manufacturer specific response event struture */
+		struct osdp_status_report status;    /**< Status report event structure */
+		struct osdp_event_notification notif;/**< Notification event structure */
 	};
 };
 
@@ -1167,7 +1243,9 @@ void osdp_get_sc_status_mask(const osdp_t *ctx, uint8_t *bitmask);
  * @param arg Opaque pointer that was provided in @ref osdp_file_ops when the
  * ops struct was registered.
  * @param file_id File ID of pre-agreed file between this CP and PD
- * @param size Size of the file that was opened (filled by application)
+ * @param size Size of the file that was opened (to be populated by sender). In
+ * case of receiver, this value is just just input to indicate the incoming file
+ * size.
  *
  * @retval 0 on success
  * @retval -1 on errors

{libosdp-3.0.6 → libosdp-3.0.8}/vendor/python/osdp_sys/cp.c

@@ -39,6 +39,9 @@ int pyosdp_cp_event_cb(void *data, int address, struct osdp_event *event)
 	pyosdp_cp_t *self = data;
 	PyObject *arglist, *result, *event_dict;
 
+	if (!self->event_cb)
+		return 0;
+
 	if (pyosdp_make_dict_event(&event_dict, event))
 		return -1;
 
@@ -86,6 +89,56 @@ static PyObject *pyosdp_cp_refresh(pyosdp_cp_t *self, pyosdp_cp_t *args)
 	Py_RETURN_NONE;
 }
 
+#define pyosdp_cp_get_pd_id_doc                                                      \
+	"Get PD_ID info as reported by the PD\n"                                     \
+	"\n"                                                                         \
+	"@param pd PD offset number\n"                                               \
+	"\n"                                                                         \
+	"@return dict with PD_ID info\n"
+static PyObject *pyosdp_cp_get_pd_id(pyosdp_cp_t *self, PyObject *args)
+{
+	int pd;
+	struct osdp_pd_id pd_id = {0};
+
+	if (!PyArg_ParseTuple(args, "I", &pd)) {
+		PyErr_SetString(PyExc_ValueError, "Invalid arguments");
+		Py_RETURN_NONE;
+	}
+
+	if (osdp_cp_get_pd_id(self->ctx, pd, &pd_id)) {
+		PyErr_SetString(PyExc_ValueError, "invalid PD offset");
+		Py_RETURN_NONE;
+	}
+
+	return pyosdp_make_dict_pd_id(&pd_id);
+}
+
+#define pyosdp_cp_check_capability_doc                                                 \
+	"Get capability associated to a function_code as reported by the PD\n"       \
+	"\n"                                                                         \
+	"@param pd PD offset number\n"                                               \
+	"@param capability function code\n"                                          \
+	"\n"                                                                         \
+	"@return (compliance_level, num_items)\n"
+static PyObject *pyosdp_cp_check_capability(pyosdp_cp_t *self, PyObject *args)
+{
+	int pd, function_code;
+	struct osdp_pd_cap cap = {0};
+
+	if (!PyArg_ParseTuple(args, "II", &pd, &function_code)) {
+		PyErr_SetString(PyExc_ValueError, "Invalid arguments");
+		Py_RETURN_NONE;
+	}
+
+	cap.function_code = function_code;
+	if (osdp_cp_get_capability(self->ctx, pd, &cap)) {
+		PyErr_SetString(PyExc_ValueError, "invalid PD offset or function code");
+		Py_RETURN_NONE;
+	}
+
+	return Py_BuildValue("(II)", cap.compliance_level, cap.num_items);
+}
+
 #define pyosdp_cp_send_command_doc                                                   \
 	"Send an OSDP command to a PD\n"                                             \
 	"\n"                                                                         \
@@ -327,6 +380,10 @@ static PyMethodDef pyosdp_cp_tp_methods[] = {
 	  METH_NOARGS, pyosdp_cp_set_flag_doc },
 	{ "clear_flag", (PyCFunction)pyosdp_cp_clear_flag,
 	  METH_NOARGS, pyosdp_cp_clear_flag_doc },
+	{ "get_pd_id", (PyCFunction)pyosdp_cp_get_pd_id,
+	  METH_VARARGS, pyosdp_cp_get_pd_id_doc },
+	{ "check_capability", (PyCFunction)pyosdp_cp_check_capability,
+	  METH_VARARGS, pyosdp_cp_check_capability_doc },
 	{ NULL, NULL, 0, NULL } /* Sentinel */
 };
 

{libosdp-3.0.6 → libosdp-3.0.8}/vendor/python/osdp_sys/data.c

@@ -44,9 +44,13 @@ static int pyosdp_make_struct_cmd_output(struct osdp_cmd *p, PyObject *dict)
 static int pyosdp_make_dict_cmd_led(PyObject *obj, struct osdp_cmd *cmd)
 {
 	bool is_temporary = false;
+	bool cancel_temporary = false;
 	struct osdp_cmd_led_params *p = &cmd->led.permanent;
 
-	if (cmd->led.temporary.control_code != 0) {
+	if (cmd->led.temporary.control_code == 1 &&
+	    cmd->led.permanent.control_code != 0) {
+		cancel_temporary = true;
+	} else if (cmd->led.temporary.control_code) {
 		p = &cmd->led.temporary;
 		is_temporary = true;
 	}
@@ -66,8 +70,14 @@ static int pyosdp_make_dict_cmd_led(PyObject *obj, struct osdp_cmd *cmd)
 		return -1;
 	if (pyosdp_dict_add_int(obj, "off_count", p->off_count))
 		return -1;
-	if (is_temporary && pyosdp_dict_add_int(obj, "timer_count", p->timer_count))
-		return -1;
+	if (is_temporary) {
+		if (pyosdp_dict_add_int(obj, "timer_count", p->timer_count))
+			return -1;
+	}
+	if (cancel_temporary) {
+		if (pyosdp_dict_add_bool(obj, "cancel_temporary", cancel_temporary))
+			return -1;
+	}
 	return 0;
 }
 
@@ -543,6 +553,37 @@ static int pyosdp_make_struct_event_status(struct osdp_event *p, PyObject *dict)
 	return 0;
 }
 
+static int pyosdp_make_dict_event_notif(PyObject *obj, struct osdp_event *event)
+{
+	if (pyosdp_dict_add_int(obj, "type", event->notif.type))
+		return -1;
+	if (pyosdp_dict_add_int(obj, "arg0", event->notif.arg0))
+		return -1;
+	if (pyosdp_dict_add_int(obj, "arg1", event->notif.arg1))
+		return -1;
+	return 0;
+}
+
+static int pyosdp_make_struct_event_notif(struct osdp_event *p, PyObject *dict)
+{
+	int type, arg0, arg1;
+	struct osdp_event_notification *ev = &p->notif;
+
+	if (pyosdp_dict_get_int(dict, "type", &type))
+		return -1;
+
+	if (pyosdp_dict_get_int(dict, "arg0", &arg0))
+		return -1;
+
+	if (pyosdp_dict_get_int(dict, "arg1", &arg1))
+		return -1;
+
+	ev->type = type;
+	ev->arg0 = arg0;
+	ev->arg1 = arg1;
+	return 0;
+}
+
 static struct {
 	int (*dict_to_struct)(struct osdp_cmd *, PyObject *);
 	int (*struct_to_dict)(PyObject *, struct osdp_cmd *);
@@ -605,6 +646,10 @@ static struct {
 		.struct_to_dict = pyosdp_make_dict_event_status,
 		.dict_to_struct = pyosdp_make_struct_event_status,
 	},
+	[OSDP_EVENT_NOTIFICATION] = {
+		.struct_to_dict = pyosdp_make_dict_event_notif,
+		.dict_to_struct = pyosdp_make_struct_event_notif,
+	},
 };
 
 /* --- Exposed Methods --- */
@@ -679,3 +724,18 @@ int pyosdp_make_dict_event(PyObject **dict, struct osdp_event *event)
 	*dict = obj;
 	return 0;
 }
+
+PyObject *pyosdp_make_dict_pd_id(struct osdp_pd_id *pd_id)
+{
+	PyObject *obj = PyDict_New();
+	if (obj == NULL)
+		return NULL;
+
+	pyosdp_dict_add_int(obj, "version", pd_id->version);
+	pyosdp_dict_add_int(obj, "model", pd_id->model);
+	pyosdp_dict_add_int(obj, "vendor_code", pd_id->vendor_code);
+	pyosdp_dict_add_int(obj, "serial_number", pd_id->serial_number);
+	pyosdp_dict_add_int(obj, "firmware_version", pd_id->firmware_version);
+
+	return obj;
+}

{libosdp-3.0.6 → libosdp-3.0.8}/vendor/python/osdp_sys/module.c

@@ -22,6 +22,9 @@ void pyosdp_add_module_constants(PyObject *module)
 	ADD_CONST("FLAG_ENFORCE_SECURE", OSDP_FLAG_ENFORCE_SECURE);
 	ADD_CONST("FLAG_INSTALL_MODE", OSDP_FLAG_INSTALL_MODE);
 	ADD_CONST("FLAG_IGN_UNSOLICITED", OSDP_FLAG_IGN_UNSOLICITED);
+	ADD_CONST("FLAG_ENABLE_NOTIFICATION", OSDP_FLAG_ENABLE_NOTIFICATION);
+	ADD_CONST("FLAG_CAPTURE_PACKETS", OSDP_FLAG_CAPTURE_PACKETS);
+	ADD_CONST("FLAG_ALLOW_EMPTY_ENCRYPTED_DATA_BLOCK", OSDP_FLAG_ALLOW_EMPTY_ENCRYPTED_DATA_BLOCK);
 
 	ADD_CONST("LOG_EMERG", OSDP_LOG_EMERG);
 	ADD_CONST("LOG_ALERT", OSDP_LOG_ALERT);
@@ -49,14 +52,20 @@ void pyosdp_add_module_constants(PyObject *module)
 	ADD_CONST("STATUS_REPORT_OUTPUT", OSDP_STATUS_REPORT_OUTPUT)
 	ADD_CONST("STATUS_REPORT_REMOTE", OSDP_STATUS_REPORT_REMOTE)
 
-	/* For `struct osdp_cmd_file_tx`::flags */
+	/* For `struct osdp_cmd_file_tx::flags` */
 	ADD_CONST("CMD_FILE_TX_FLAG_CANCEL", OSDP_CMD_FILE_TX_FLAG_CANCEL);
 
+	/* For `struct osdp_event_notification::type` */
+	ADD_CONST("EVENT_NOTIFICATION_COMMAND", OSDP_EVENT_NOTIFICATION_COMMAND);
+	ADD_CONST("EVENT_NOTIFICATION_SC_STATUS", OSDP_EVENT_NOTIFICATION_SC_STATUS);
+	ADD_CONST("EVENT_NOTIFICATION_PD_STATUS", OSDP_EVENT_NOTIFICATION_PD_STATUS);
+
 	/* enum osdp_event_type */
 	ADD_CONST("EVENT_CARDREAD", OSDP_EVENT_CARDREAD);
 	ADD_CONST("EVENT_KEYPRESS", OSDP_EVENT_KEYPRESS);
 	ADD_CONST("EVENT_MFGREP", OSDP_EVENT_MFGREP);
 	ADD_CONST("EVENT_STATUS", OSDP_EVENT_STATUS);
+	ADD_CONST("EVENT_NOTIFICATION", OSDP_EVENT_NOTIFICATION);
 
 	/* enum osdp_led_color_e */
 	ADD_CONST("LED_COLOR_NONE", OSDP_LED_COLOR_NONE);

{libosdp-3.0.6 → libosdp-3.0.8}/vendor/python/osdp_sys/module.h

@@ -91,5 +91,6 @@ int pyosdp_make_struct_cmd(struct osdp_cmd *cmd, PyObject *dict);
 int pyosdp_make_dict_cmd(PyObject **dict, struct osdp_cmd *cmd);
 int pyosdp_make_dict_event(PyObject **dict, struct osdp_event *event);
 int pyosdp_make_struct_event(struct osdp_event *event, PyObject *dict);
+PyObject *pyosdp_make_dict_pd_id(struct osdp_pd_id *pd_id);
 
 #endif /* _PYOSDP_H_ */

{libosdp-3.0.6 → libosdp-3.0.8}/vendor/src/osdp_common.c

@@ -32,7 +32,7 @@ uint16_t osdp_compute_crc16(const uint8_t *buf, size_t len)
 	return crc16_itu_t(0x1D0F, buf, len);
 }
 
-int64_t osdp_millis_now(void)
+__weak int64_t osdp_millis_now(void)
 {
 	return millis_now();
 }
@@ -100,7 +100,7 @@ const char *osdp_reply_name(int reply_id)
 		[REPLY_RSTATR    - REPLY_ACK] = "RSTATR",
 		[REPLY_RAW       - REPLY_ACK] = "RAW",
 		[REPLY_FMT       - REPLY_ACK] = "FMT",
-		[REPLY_KEYPPAD   - REPLY_ACK] = "KEYPPAD",
+		[REPLY_KEYPAD    - REPLY_ACK] = "KEYPAD",
 		[REPLY_COM       - REPLY_ACK] = "COM",
 		[REPLY_BIOREADR  - REPLY_ACK] = "BIOREADR",
 		[REPLY_BIOMATCHR - REPLY_ACK] = "BIOMATCHR",