ilguard.h

См. документацию.

 
#ifndef ILGUARD_H_INCLUDED
#define ILGUARD_H_INCLUDED
#include <stdint.h>  // для uint8_t, uint32_t
#include <string.h>  // для memcpy, memset и memcmp
 
#ifndef ILG_STATIC_DEFINE
#include <ilguard/export_shared.h>
#else
#include <ilguard/export_static.h>
#endif
 
// #define ILGUARD_LINKONREQUEST
 
#define ILG_VERSION_MAJOR 1
#define ILG_VERSION_MINOR 1
#define ILG_VERSION_PATCH 1
#define ILG_VERSION \
    ((ILG_VERSION_MAJOR << 24) | (ILG_VERSION_MINOR << 16) | (ILG_VERSION_PATCH << 8) | 0xC0)
 
#define ILG_VERSION_GET_MAJOR(v) ((v) >> 24)
#define ILG_VERSION_GET_MINOR(v) (((v) >> 16) & 0xff)
#define ILG_VERSION_GET_PATCH(v) (((v) >> 8) & 0xff)
#define ILG_AUTOALLOCATE 0xffffffff
 
typedef void* ilg_handle;
 
typedef enum : int {
    ILG_FALSE,  
    ILG_TRUE  
} ilg_bool;
 
typedef enum {
    ILG_OK = 0,
    ILG_E_FAIL,
    ILG_E_PENDING,
    ILG_E_BOUNDS,
    ILG_E_NOTIMPL,
    ILG_E_POINTER,
    ILG_E_ABORT,
    ILG_E_HANDLE,
    ILG_E_OUTOFMEMORY,
    ILG_E_INVALIDARG,
    ILG_E_WRONG_SDK_VERSION,
    ILG_E_NOT_INITIALIZED,
    ILG_E_BUFFER_TOO_SMALL,
    ILG_E_OUT_OF_RESOURCES,
    ILG_E_BLOCKING_CALL_NOT_ALLOWED,
    ILG_E_PORT_NOT_EXIST,
    ILG_E_PORT_ACCESS_DENIED,
    ILG_E_PORT_OPEN_FAILED,
    ILG_E_CONNECTION_ERROR,
    ILG_E_CONNECTION_DOWN,
    ILG_E_REQUEST_TIMEOUT,
    ILG_E_BAD_RESPONSE,
    ILG_E_CONVERTER_ERROR,
    ILG_E_CTR_NOT_EXIST,
    ILG_E_LICENSE_ERROR,
    ILG_E_LICENSE_NOT_FOUND,
    ILG_E_LICENSE_EXPIRED,
    ILG_E_LICENSE_CONTROLLERS,
    ILG_E_LICENSE_READ_KEYS,
    ILG_E_LICENSE_WRITE_KEYS,
    ILG_E_NOT_SUPPORTED,
    ILG_E_FIRMWARE_FILESIZE,
    ILG_E_BOOTLOADER_NOSTART,
    ILG_E_NO_COMPATIBLE,
    ILG_E_INVALID_DEV_NUM,
    ILG_E_TOOLARGE_FIRMWARE,
    ILG_E_SEQUENCE_DATA,
    ILG_E_DATA_INTEGRITY,
    ILG_E_FIRMWARE_OTHER,
    ILG_E_RUN_FIRMWARE_FAIL,
    ILG_E_FIRMWARE_IMAGE_INVALID,
    ILG_E_CTR_NACK,
    ILG_E_PORT_BUSY,
    ILG_STATUS_SIZE
} ilg_status;
 
#define ILG_SUCCEEDED(status) ((status) == ILG_OK)
 
#define ILG_FAILED(status) ((status) != ILG_OK)
 
typedef enum {
    ILG_PORT_TYPE_UNKNOWN,
    ILG_PORT_TYPE_COMPORT,
    ILG_PORT_TYPE_SERVER,
    ILG_PORT_TYPE_CLIENT,
    ILG_PORT_TYPE_PROXY,
    ILG_PORT_TYPE_SIZE
} ilg_port_type;
 
typedef enum {
    ILG_CONVERTER_MODEL_UNKNOWN,
    ILG_CONVERTER_MODEL_Z397,
    ILG_CONVERTER_MODEL_STRAG,
    ILG_CONVERTER_MODEL_STRAG115,
    ILG_CONVERTER_MODEL_Z397_GUARD,
    ILG_CONVERTER_MODEL_Z397_IP,
    ILG_CONVERTER_MODEL_Z397_WEB,
    ILG_CONVERTER_MODEL_Z5R_WEB,
    ILG_CONVERTER_MODEL_MATRIX2_WIFI,
    ILG_CONVERTER_MODEL_MATRIX6_WIFI,
    ILG_CONVERTER_MODEL_Z5R_WEB_BT,
    ILG_CONVERTER_MODEL_Z5R_WIFI,
    ILG_CONVERTER_MODEL_MATRIX2_EH_WEB,
    ILG_CONVERTER_MODEL_MATRIX6_EH_WEB,
    ILG_CONVERTER_MODEL_Z5R_WEB_MINI,
    ILG_CONVERTER_MODEL_MATRIX6_NFC_WIFI,
    ILG_CONVERTER_MODEL_SIZE
} ilg_converter_model;
 
typedef enum {
    ILG_CONVERTER_MODE_UNKNOWN,
    ILG_CONVERTER_MODE_NORMAL,
    ILG_CONVERTER_MODE_ADVANCED,
    ILG_CONVERTER_MODE_TEST,
    ILG_CONVERTER_MODE_ACCEPT,
    ILG_CONVERTER_MODE_SIZE
} ilg_converter_mode;
 
typedef enum {
    ILG_LOCK_UNKNOWN,
    ILG_LOCK_ON,
    ILG_LOCK_OFF,
    ILG_LOCK_SIZE
} ilg_lock_state;
 
typedef enum {
    ILG_CONTROLLER_MODEL_UNKNOWN,
    ILG_CONTROLLER_MODEL_GATE2000,
    ILG_CONTROLLER_MODEL_MATRIX2_NET,
    ILG_CONTROLLER_MODEL_Z5R_NET,
    ILG_CONTROLLER_MODEL_Z5R_NET_8K,
    ILG_CONTROLLER_MODEL_Z5R_NET_16000,
    ILG_CONTROLLER_MODEL_MATRIX3_NET,
    ILG_CONTROLLER_MODEL_GUARD_NET,
    ILG_CONTROLLER_MODEL_Z5R_WEB,
    ILG_CONTROLLER_MODEL_MATRIX2_WIFI,
    ILG_CONTROLLER_MODEL_ZEUROLOCK,
    ILG_CONTROLLER_MODEL_Z9_EHT_NET,
    ILG_CONTROLLER_MODEL_MATRIX6_NFC_K_NET,
    ILG_CONTROLLER_MODEL_MATRIX6_EH_K_NET,
    ILG_CONTROLLER_MODEL_MATRIX6_WIFI,
    ILG_CONTROLLER_MODEL_Z5R_WEB_BT,
    ILG_CONTROLLER_MODEL_Z5R_WIFI,
    ILG_CONTROLLER_MODEL_MATRIX2_EH_WEB,
    ILG_CONTROLLER_MODEL_MATRIX6_EH_WEB,
    ILG_CONTROLLER_MODEL_Z5R_WEB_MINI,
    ILG_CONTROLLER_MODEL_MATRIX6_NFC_WIFI,
    ILG_CONTROLLER_MODEL_CP_Z2_EH_K_RELAY,
    ILG_CONTROLLER_MODEL_CP_Z2_EH_K,
    ILG_CONTROLLER_MODEL_SIZE
} ilg_controller_model;
 
typedef enum {
    ILG_LOG_LEVEL_NONE,
 
    ILG_LOG_LEVEL_ERROR,
 
    ILG_LOG_LEVEL_WARNING,
 
    ILG_LOG_LEVEL_INFO,
 
    ILG_LOG_LEVEL_DEBUG,
    ILG_LOG_LEVEL_SIZE
} ilg_log_level;
 
typedef void (*ilg_logging_callback)(ilg_log_level nLevel, const char* pContext,
                                     const char* pMessage, void* pUserData);
 
typedef struct {
    ilg_bool fTwoStopBits;
    int nRequestTimeout;
    int nRequestAttempts;
} ilg_options;
 
typedef ilg_bool (*ilg_filter_port_callback)(ilg_port_type nPortType, const char* pszPortName,
                                             void* pUserData);
 
typedef struct {
    ilg_port_type nPortType;
    const char* pszPortName;
    const char* pszConnect;
    ilg_converter_model nModel;
    int nSn;
    uint32_t nFwVersion;
    int64_t nFwBuildDate;
    ilg_converter_mode nMode;
    int64_t nAuthKey;
    ilg_lock_state nLock;
    ilg_status nError;
} ilg_converter_info;
 
typedef struct {
    uint16_t nTcpPort;
    ilg_status nError;
} ilg_listen_error_info;
 
typedef enum {
    ILG_SEARCH_MSG_COMMAND_FINISH,
    ILG_SEARCH_MSG_CONVERTER_FOUND,
    ILG_SEARCH_MSG_CONVERTER_LOST,
    ILG_SEARCH_MSG_LIST_CHANGED,
    ILG_SEARCH_MSG_LISTEN_PORT_OPEN,
    ILG_SEARCH_MSG_LISTEN_PORT_CLOSED,
    ILG_SEARCH_MSG_LISTEN_ERROR
} ilg_search_msg;
 
typedef void (*ilg_search_message_callback)(ilg_search_msg nMsg, const void* pMsgData,
                                            void* pUserData);
 
typedef enum : uint32_t {
    ILG_CONVERTER_ILUSB = (1 << 0),
    ILG_CONVERTER_TPUSB = (1 << 1),
    ILG_CONVERTER_SERVER = (1 << 2),
    ILG_CONVERTER_CLIENT = (1 << 3)
} ilg_converter_types;
 
typedef struct {
    uint32_t nConverterTypes;
    int nOpenPortPeriod;
    int nPollPeriod;
    int nUdpScanPeriod;
    int nUdpRequestTimeout;
    int nUdpRequestAttempts;
    int nOpenListenerPeriod;
    int nAcceptTimeout;
} ilg_search_options;
 
typedef enum {
    ILG_CONNECTION_DISCONNECTED,  
    ILG_CONNECTION_CONNECTED,     
    ILG_CONNECTION_CONNECTING,    
    ILG_CONNECTION_SIZE           
} ilg_connection_status;
 
typedef struct {
    uint8_t nLicenseN;
    uint8_t nControllers;
    uint16_t nKeys;
    uint16_t nExpireDate;
    uint16_t nCountdown;
} ilg_license_info;
 
#define ILG_EXPIREDATE_DAY(date) ((date)&0x1F)
#define ILG_EXPIDEDATE_MONTH(date) (((date) >> 5) & 0xF)
#define ILG_EXPIDEDATE_YEAR(date, current_year) (((current_year) / 100) * 100 + ((date) >> 9))
 
#define ILG_LICENSE_N 5
 
typedef enum {
    ILG_CONVERTER_MSG_COMMAND_FINISH,
    ILG_CONVERTER_MSG_CONNECTION_CHANGED,
    ILG_CONVERTER_MSG_CONTROLLER_FOUND,
    ILG_CONVERTER_MSG_CONTROLLER_LOST,
    ILG_CONVERTER_MSG_CONTROLLER_LIST_CHANGED,
    ILG_CONVERTER_MSG_CONTROLLER_ADDRESS_CHAMGED
} ilg_converter_msg;
 
typedef void (*ilg_converter_message_callback)(ilg_converter_msg nMsg, const void* pMsgData,
                                               void* pUserData);
 
typedef enum : uint32_t {
    ILG_CTR_TYPE_F_NETCTR = (1 << 0),
    ILG_CTR_TYPE_F_ELOCK = (1 << 1)
} ilg_ctr_type_flags;
 
typedef enum {
    ILG_CTR_SCAN_METHOD_AUTO,
    ILG_CTR_SCAN_METHOD_RANGE,
    ILG_CTR_SCAN_METHOD_POLL,
    ILG_CTR_SCAN_METHOD_SIZE
} ilg_ctr_scan_method;
 
typedef struct {
    ilg_converter_model nConnectModel;
 
    uint32_t nSpeed;
 
    ilg_bool fNormalMode;
 
    int nReconnectPeriod;
 
    int nScanPeriod;
 
    uint32_t nScanDeviceTypes;
 
    ilg_ctr_scan_method nScanMethod;
 
    uint32_t nLastPolledAddress;
 
    int nPollTimeout;
 
    ilg_bool fReassignAddress01;
} ilg_converter_options;
 
typedef enum : uint32_t {
    ILG_CTR_F_TWOBANKS = (1 << 0),
    ILG_CTR_F_WIEGAND = (1 << 1),
    ILG_CTR_F_JOIN = (1 << 2),
    ILG_CTR_F_X2 = (1 << 3),
    ILG_CTR_F_EC = (1 << 4),
    ILG_CTR_F_MODES = (1 << 5),
    ILG_CTR_F_DUALZONE = (1 << 6),
    ILG_CTR_F_OLDEMERGOPEN = (1 << 7),
    ILG_CTR_F_CONFIG = (1 << 8),
    ILG_CTR_F_EXTASK = (1 << 9),
    ILG_CTR_F_APB = (1 << 10),
    ILG_CTR_F_BIGTIME = (1 << 11),
    ILG_CTR_F_ANTICOVID = (1 << 12),
    ILG_CTR_F_DUALCARD = (1 << 13)
} ilg_controller_flags;
 
typedef enum {
    ILG_PASS_POINT_UNKNOWN,
    ILG_PASS_POINT_DOOR,
    ILG_PASS_POINT_TURNSTILE,
    ILG_PASS_POINT_GATEWAY,
    ILG_PASS_POINT_BARRIER,
    ILG_PASS_POINT_EMAGNETIC,
    ILG_PASS_POINT_EMECHANICAL,
    ILG_PASS_POINT_TURNSTILE2,
    ILG_PASS_POINT_MOTOR_TWO_RELAYS,
    ILG_PASS_POINT_MOTOR_ONE_RELAYS,
    ILG_PASS_POINT_ELECTROCONTROL,
    ILG_PASS_POINT_AUTOCONTROL,
    ILG_PASS_POINT_SIZE
} ilg_pass_point_type;
 
typedef enum {
    ILG_CONTROLLER_MODE_INACTIVE,
    ILG_CONTROLLER_MODE_NORMAL,
    ILG_CONTROLLER_MODE_BLOCK,
    ILG_CONTROLLER_MODE_FREE,
    ILG_CONTROLLER_MODE_WAIT,
    ILG_CONTROLLER_MODE_SIZE
} ilg_controller_mode;
 
typedef struct {
    ilg_controller_model nModel;
    uint8_t nModelCode;
    uint8_t nAddress;
    uint32_t nFwVersion;
    int nSn;
    uint32_t nBankSize;
    ilg_pass_point_type nPassPoint;
    uint32_t nCtrFlags;
    uint32_t nInitCtrFlags;
} ilg_controller_info;
 
typedef enum {
    ILG_CONTROLLER_MSG_COMMAND_FINISH,
    ILG_CONTROLLER_MSG_CONNECTION_CHANGED,
    ILG_CONTROLLER_MSG_ADDRESS_CHANGED,
    ILG_CONTROLLER_MSG_CLOCK_OUT_OF_SYNC,
    ILG_CONTROLLER_MSG_RTC_CHANGED,
    ILG_CONTROLLER_MSG_EXTASK_CHANGED
} ilg_controller_msg;
 
typedef void (*ilg_controller_message_callback)(ilg_controller_msg nMsg, const void* pMsgData,
                                                void* pUserData);
 
typedef struct {
    union {
        uint64_t nData;      
        uint8_t aDallas[6];  
 
        struct {                   
            uint16_t nNumber;      
            uint8_t nSeries;       
            uint8_t aFacility[3];  
        } em_marine;
 
        struct {
            uint8_t aDallas1[3];
            uint8_t aDallas2[3];
        } dual_dallas;
 
        struct {
            uint16_t nNumber1;  
            uint8_t nSeries1;   
            uint16_t nNumber2;  
            uint8_t nSeries2;   
        } dual_em_marine;
    };
} ilg_key_number;
 
typedef struct {
    uint8_t nDaysOfWeek;
 
    uint8_t nBeginHour;
 
    uint8_t nBeginMinute;
 
    uint8_t nEndHour;
 
    uint8_t nEndMinute;
 
    uint8_t nPowerConfig;
 
    uint8_t nEcDelaySec;
} ilg_time_zone;
 
typedef struct {
    uint8_t nDaysOfWeek;
    uint8_t nBeginHour;
    uint8_t nBeginMinute;
    uint8_t nEndHour;
    uint8_t nEndMinute;
    ilg_controller_mode nMode;
} ilg_mode_time_zone;
 
typedef enum {
    ILG_KEY_NORMAL,
    ILG_KEY_BLOCKING,
    ILG_KEY_MASTER,
    ILG_KEY_TYPE_SIZE
} ilg_key_type;
 
typedef enum : uint32_t {
    ILG_KEY_F_FUNC = (1 << 1),
    ILG_KEY_F_DUAL = (1 << 2),
    ILG_KEY_F_SHORT = (1 << 5)
} ilg_key_flags;
 
typedef struct {
    uint8_t fErased;
    uint8_t nFlags;
    uint8_t nAccess;
    uint8_t fSelected;
    ilg_key_type nType;
    ilg_key_number rNumber;
} ilg_key;
 
typedef enum {
    ILG_EVENT_UNKNOWN,
    ILG_EVENT_BUTTON_OPEN,
    ILG_EVENT_KEY_NOT_FOUND,
    ILG_EVENT_KEY_OPEN,
    ILG_EVENT_KEY_ACCESS,
    ILG_EVENT_REMOTE_OPEN,
    ILG_EVENT_KEY_DOOR_BLOCK,
    ILG_EVENT_BUTTON_DOOR_BLOCK,
    ILG_EVENT_NO_OPEN,
    ILG_EVENT_NO_CLOSE,
    ILG_EVENT_PASSAGE,
    ILG_EVENT_REBOOT,
    ILG_EVENT_BUTTON_BLOCK,
    ILG_EVENT_DBL_PASSAGE,
    ILG_EVENT_OPEN,
    ILG_EVENT_CLOSE,
    ILG_EVENT_POWER_OFF,
    ILG_EVENT_POWER_ON,
    ILG_EVENT_LOCK_CONNECT,
    ILG_EVENT_LOCK_DISCONNECT,
    ILG_EVENT_ELECTROCONTROL,
    ILG_EVENT_CONTROLLER_MODE,
    ILG_EVENT_FIRE,
    ILG_EVENT_SECURITY,
    ILG_EVENT_GATEWAY_PASS,
    ILG_EVENT_GATEWAY_BLOCK,
    ILG_EVENT_GATEWAY_ALLOWED,
    ILG_EVENT_ANTIPASSBACK,
    ILG_EVENT_HOTEL40,
    ILG_EVENT_HOTEL41,
    ILG_EVENT_KEY_NUMBER,
    ILG_EVENT_TYPE_SIZE
} ilg_event_type;
 
typedef enum {
    ILG_EVENT_FORMAT_UNKNOWN,
    ILG_EVENT_FORMAT_PASSAGE,
    ILG_EVENT_FORMAT_TIME,
    ILG_EVENT_FORMAT_CONTROLLER_MODE,
    ILG_EVENT_FORMAT_STATE,
    ILG_EVENT_FORMAT_KEY_NUMBER
} ilg_event_format;
 
typedef enum {
    ILG_DIRECTION_UNKNOWN,
    ILG_DIRECTION_IN,
    ILG_DIRECTION_OUT,
    ILG_DIRECTION_SIZE
} ilg_direction;
 
typedef enum : uint32_t {
    ILG_ECPC_F_ENABLED = (1 << 0),
    ILG_ECPC_F_SCHEDULE = (1 << 1),
    ILG_ECPC_F_EXT_READER = (1 << 2),
    ILG_ECPC_F_INVERT = (1 << 3),
    ILG_ECPC_F_EXIT_OFF = (1 << 4),
    ILG_ECPC_F_CARD_OPEN = (1 << 5)
} ilg_ecpc_flags;
 
typedef struct {
    int64_t nDiffSec;
    ssize_t nEventWriteIdx;
    ssize_t nEventReadIdx;
    ilg_key_number rLastKey;
    ilg_bool fEmergencyOpen;
} ilg_rtc_params;
 
typedef struct {
    uint16_t nYear;      
    uint8_t nMonth;      
    uint8_t nDayOfWeek;  
    uint8_t nDay;        
    uint8_t nHour;       
    uint8_t nMinute;     
    uint8_t nSecond;     
} ilg_controller_time;
 
typedef struct {
    ilg_controller_mode nMode;
    uint8_t nClockSec;
    uint8_t n12V;
    uint8_t nT;
    uint8_t nCR2032;
    uint8_t nState;
} ilg_extask_params;
 
typedef struct {
    ilg_bool fAutoSyncClock;
    int nCheckRtcPeriod;
    int nExtAskPeriod;
} ilg_controller_options;
 
typedef struct {
    uint8_t nCRC;
    uint8_t nVersion;
 
    union {
        uint16_t nFlags;
 
        struct {
            uint16_t ctCardMode : 1,  
                ctDual_zone : 1,      
                ctReaderMode : 1,     
                ctAPB : 1,            
                blk_oxr : 1,          
                flgUnused5 : 1,       
                flgUnused6 : 1,       
                ctAltWieg : 1,        
                ctMemSize : 3,        
                ctUniBank : 1,        
                joinbank : 1;         
        } sys_flags;
    };
 
    uint16_t nGrn_mask;  
    uint16_t nRed_mask;  
    uint16_t nSnd_mask;  
    uint16_t nAlarm_mask;  
    uint16_t nPower_mask;  
    uint16_t nGate_msk;    
    uint16_t nBell_mask;   
    uint8_t nD0_dn;  
    uint8_t nD0_up;  
    uint8_t nD1_dn;  
    uint8_t nD1_up;  
    uint8_t nGRN_dn;  
    uint8_t nGRN_up;  
    uint8_t nRED_dn;  
    uint8_t nRED_up;  
    uint8_t nSND_dn;  
    uint8_t nSND_up;  
    uint8_t nLOCK0_dn;  
    uint8_t nLOCK0_up;  
    uint8_t nLOCK1_dn;  
    uint8_t nLOCK1_up;  
    uint8_t nLOCK2_dn;  
    uint8_t nLOCK2_up;  
    uint8_t nBUTT0_dn;  
    uint8_t nBUTT0_up;  
    uint8_t nBUTT1_dn;  
    uint8_t nBUTT1_up;  
    uint8_t nBUTT2_dn;  
    uint8_t nBUTT2_up;  
    uint8_t nDOOR0_dn;  
    uint8_t nDOOR0_up;  
    uint8_t nDOOR1_dn;  
    uint8_t nDOOR1_up;  
    uint8_t nDOOR2_dn;  
    uint8_t nDOOR2_up;  
    uint8_t nEXT0_dn;  
    uint8_t nEXT0_up;  
    uint8_t nEXT1_dn;  
    uint8_t nEXT1_up;  
    uint8_t nEXT2_dn;  
    uint8_t nEXT2_up;  
 
    union {
        uint32_t nLock_flags;  
 
        struct {
            uint32_t activator : 1;     
            uint32_t trigmode : 1;      
            uint32_t duallock : 1;      
            uint32_t no_wait_door : 1;  
            uint32_t unblock_door : 1;  
            uint32_t nightlock : 1;     
            uint32_t nightconf : 1;  
            uint32_t no_long_pwr : 1;  
        } lock_flags;
    };
 
    uint16_t aLock_mask[4];  
    uint8_t aLock_cmd[16];   
} ilg_z5rw_config;
 
typedef struct {
    uint8_t nCRC;
    uint8_t nVersion;
 
    union {
        uint16_t nFlags;
 
        struct {
            uint16_t ctCardMode : 1,  // 0 CardMode (для памяти).
                ctDual_zone : 1,      // 1 Использование двух зон.
                ctReaderMode : 1,     // 2 Режим считывателей (Dallas/Wiegand).
                ctAPB : 1,            // 3 Антипассбэк.
                blk_oxr : 1,          // 4 Блокировка включает охрану.
                ctFireButt : 1,       // 5 Пожарная тревога по кнопке.
                flgUnused6 : 1,       // 6 Не занято.
                flgUnused7 : 1,       // 7 Не занято.
 
                ctMemSize : 3,  // 8 Размер конфигурации памяти.
                ctUniBank : 1,  // 11 Один банк карт.
                joinbank : 1;   // 12 Режим JOIN.
        } sys_flags;
    };
 
    uint16_t nGrn_mask;  
    uint16_t nRed_mask;  
    uint16_t nSnd_mask;  
    uint16_t nAlarm_mask;  
    uint16_t nPower_mask;  
    uint16_t nGate_msk;    
    uint16_t nBell_mask;   
    uint8_t nD0_dn;  
    uint8_t nD0_up;  
    uint8_t nD1_dn;  
    uint8_t nD1_up;  
    uint8_t nZP0_dn;  
    uint8_t nZP0_up;  
    uint8_t nZP1_dn;  
    uint8_t nZP1_up;  
    uint8_t nZP2_dn;  
    uint8_t nZP2_up;  
    uint8_t nLED0_dn;  
    uint8_t nLED0_up;  
    uint8_t nLED1_dn;  
    uint8_t nLED1_up;  
    uint8_t nLED2_dn;  
    uint8_t nLED2_up;  
    uint8_t nDOOR0_dn;  
    uint8_t nDOOR0_up;  
    uint8_t nDOOR1_dn;  
    uint8_t nDOOR1_up;  
    uint8_t nDOOR2_dn;  
    uint8_t nDOOR2_up;  
 
    union {
        uint32_t nLock_flags;  
 
        struct {
            uint32_t activator : 1;     
            uint32_t trigmode : 1;      
            uint32_t duallock : 1;      
            uint32_t no_wait_door : 1;  
            uint32_t unblock_door : 1;  
            uint32_t nightlock : 1;     
            uint32_t nightconf : 1;  
            uint32_t no_long_pwr : 1;  
        } lock_flags;
    };
 
    uint16_t aLock_mask[4];  
    uint8_t aLock_cmd[16];   
} ilg_m2wf_config;
 
typedef struct {
    uint8_t nCRC;
    uint8_t nVersion;
 
    union {
        uint16_t nFlags;
 
        struct {
            uint16_t ctCardMode : 1,  // 0 CardMode (для памяти).
                ctDual_zone : 1,      // 1 Использование двух зон.
                led_act : 1,          // 2 led принимать как аналог.
                zp_act : 1,           // 3 zp принимать как аналог.
                blk_oxr : 1,          // 4 Блокировка включает охрану.
                ctReaderMode : 1,     // 5 Режим считывателей (Dallas/Wiegand).
                flgUnused6 : 1,       // 6 Не занято.
                flgUnused7 : 1;       // 7 Не занято.
        } sys_flags;
    };
 
    uint8_t nGrn_mask;  
    uint8_t nRed_mask;  
    uint8_t nSnd_mask;  
    uint8_t nAlarm_mask;  
    uint8_t nPower_mask;  
    uint8_t nGate_msk;    
    uint8_t nBell_mask;   
    uint8_t nD0_dn;  
    uint8_t nD0_up;  
    uint8_t nD1_dn;  
    uint8_t nD1_up;  
    uint8_t nZP0_dn;  
    uint8_t nZP0_up;  
    uint8_t nZP1_dn;  
    uint8_t nZP1_up;  
    uint8_t nZP2_dn;  
    uint8_t nZP2_up;  
    uint8_t nLED0_dn;  
    uint8_t nLED0_up;  
    uint8_t nLED1_dn;  
    uint8_t nLED1_up;  
    uint8_t nLED2_dn;  
    uint8_t nLED2_up;  
    uint8_t nDOOR0_dn;  
    uint8_t nDOOR0_up;  
    uint8_t nDOOR1_dn;  
    uint8_t nDOOR1_up;  
    uint8_t nDOOR2_dn;  
    uint8_t nDOOR2_up;  
 
    union {
        uint8_t nLock_flags;  
 
        struct {
            uint8_t activator : 1;     
            uint8_t trigmode : 1;      
            uint8_t duallock : 1;      
            uint8_t no_wait_door : 1;  
            uint8_t unblock_door : 1;  
            uint8_t nightlock : 1;     
            uint8_t nightconf : 1;  
            uint8_t no_long_pwr : 1;  
        } lock_flags;
    };
 
    uint8_t aLock_mask[4];  
    uint8_t aLock_cmd[16];  
} ilg_z5rnet_config;
 
#ifdef __cplusplus
extern "C" {
#endif
 
ILGUARD_EXPORT uint32_t ilg_get_version();
 
ILGUARD_EXPORT const char* ilg_get_error_text(ilg_status nErrorCode);
 
ILGUARD_EXPORT ilg_status ilg_set_log_level(ilg_log_level nLevel);
 
ILGUARD_EXPORT ilg_status ilg_set_log_callback(ilg_logging_callback pCallback,
                                               void* pUserData = nullptr);
 
ILGUARD_EXPORT ilg_status ilg_free_memory(void* p);
 
inline bool ilg_check_version() {
    auto v = ilg_get_version();
    return ((((v >> 24) & 0xff) == ILG_VERSION_MAJOR) &&
            ((int)((v >> 16) & 0xff) >= ILG_VERSION_MINOR));
}
 
ILGUARD_EXPORT ilg_status ilg_init(uint32_t nVersionRequested = ILG_VERSION);
 
ILGUARD_EXPORT ilg_status ilg_cleanup();
 
ILGUARD_EXPORT ilg_status ilg_close_handle(ilg_handle h);
 
ILGUARD_EXPORT ilg_status ilg_clone_handle(ilg_handle h, ilg_handle* pNewHandle);
 
ILGUARD_EXPORT ilg_status ilg_set_filter_port_callback(ilg_filter_port_callback pCallback,
                                                       void* pUserData = nullptr);
 
ILGUARD_EXPORT ilg_status ilg_set_options(const ilg_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_get_options(ilg_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_get_search(ilg_handle* pSearch);
 
ILGUARD_EXPORT ilg_status ilg_get_converter(ilg_port_type nPortType, const char* pszPortName,
                                            ilg_handle* pConverter);
 
ILGUARD_EXPORT ilg_status ilg_search_set_message_callback(ilg_handle hSearch,
                                                          ilg_search_message_callback pCallback,
                                                          void* pUserData = nullptr);
 
ILGUARD_EXPORT ilg_status ilg_search_enable_message_queue(ilg_handle hSearch,
                                                          ilg_bool fEnable = ILG_TRUE);
 
ILGUARD_EXPORT ilg_status ilg_search_get_message(ilg_handle hSearch, ilg_search_msg* pMsg,
                                                 const void** pMsgData, ilg_bool* pFound);
 
ILGUARD_EXPORT ilg_status ilg_search_set_options(ilg_handle hSearch,
                                                 const ilg_search_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_search_get_options(ilg_handle hSearch, ilg_search_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_search_set_listen_ports(ilg_handle hSearch, const uint16_t* pPorts,
                                                      size_t nCount);
 
ILGUARD_EXPORT ilg_status ilg_search_get_listen_ports(ilg_handle hSearch, uint16_t* pBuf,
                                                      size_t* pSize);
 
ILGUARD_EXPORT ilg_status ilg_search_get_listen_status(ilg_handle hSearch, uint16_t nTcpPort,
                                                       ilg_status* pStatus);
 
ILGUARD_EXPORT ilg_status ilg_search_scan(ilg_handle hSearch, ilg_bool fReset = ILG_FALSE);
 
ILGUARD_EXPORT ilg_status ilg_search_begin_scan(ilg_handle hSearch, ilg_bool fReset,
                                                ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_search_get_converter_count(ilg_handle hSearch, size_t* pCount);
 
ILGUARD_EXPORT ilg_status ilg_search_get_converter_info(ilg_handle hSearch, size_t nIdx,
                                                        ilg_converter_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_search_set_auto_scan(ilg_handle hSearch, ilg_bool fEnable = ILG_TRUE,
                                                   ilg_bool fWait = ILG_TRUE);
 
ILGUARD_EXPORT ilg_status ilg_search_begin_set_auto_scan(ilg_handle hSearch, ilg_bool fEnable,
                                                         ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_search_get_auto_scan(ilg_handle hSearch, ilg_bool* pEnabled);
 
ILGUARD_EXPORT ilg_status ilg_search_open_port(ilg_handle hSearch, ilg_port_type nPortType,
                                               const char* pszPortName, ilg_converter_info* pInfo,
                                               int* pPort);
 
ILGUARD_EXPORT ilg_status ilg_search_begin_open_port(ilg_handle hSearch, ilg_port_type nPortType,
                                                     const char* pszPortName, ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_search_end_open_port(ilg_handle hCommand, int* pPortFD,
                                                   ilg_converter_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_search_close_port(ilg_handle hSearch, ilg_port_type nPortType,
                                                const char* pszPortName, int hPort);
 
ILGUARD_EXPORT ilg_status ilg_search_begin_close_port(ilg_handle hSearch, ilg_port_type nPortType,
                                                      const char* pszPortName, int hPortFD,
                                                      ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_set_message_callback(
    ilg_handle hConverter, ilg_converter_message_callback pCallback, void* pUserData = nullptr);
 
ILGUARD_EXPORT ilg_status ilg_converter_enable_message_queue(ilg_handle hConverter,
                                                             ilg_bool fEnable = ILG_TRUE);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_message(ilg_handle hConverter, ilg_converter_msg* pMsg,
                                                    const void** pMsgData, ilg_bool* pFound);
 
ILGUARD_EXPORT ilg_status ilg_converter_set_options(ilg_handle hConverter,
                                                    const ilg_converter_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_options(ilg_handle hConverter,
                                                    ilg_converter_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_converter_connect(ilg_handle hConverter,
                                                ilg_bool fReconnect = ILG_FALSE);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_connect(ilg_handle hConverter, ilg_bool fReconnect,
                                                      ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_disconnect(ilg_handle hConverter);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_disconnect(ilg_handle hConverter,
                                                         ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_connection_status(ilg_handle hConverter,
                                                              ilg_connection_status* pStatus);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_info(ilg_handle hConverter, ilg_converter_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_converter_read_license_info(ilg_handle hConverter,
                                                          ilg_license_info* pInfo,
                                                          uint32_t nLicenseN = ILG_LICENSE_N,
                                                          ilg_bool fForce = ILG_FALSE);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_read_license_info(ilg_handle hConverter,
                                                                uint32_t nLicenseN,
                                                                ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_end_read_license_info(ilg_handle hCommand,
                                                              ilg_license_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_license_count(ilg_handle hConverter, size_t* pCount);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_get_license_count(ilg_handle hConverter,
                                                                ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_end_get_license_count(ilg_handle hCommand, size_t* pCount);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_license_info(ilg_handle hConverter, size_t nIdx,
                                                         ilg_license_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_converter_write_license(ilg_handle hConverter, const void* pData,
                                                      size_t nSize,
                                                      ilg_license_info* pInfo = nullptr,
                                                      uint32_t nLicenseN = ILG_LICENSE_N);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_write_license(ilg_handle hConverter,
                                                            const void* pData, size_t nSize,
                                                            uint32_t nLicenseN,
                                                            ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_end_write_license(ilg_handle hCommand,
                                                          ilg_license_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_converter_clear_licenses(ilg_handle hConverter,
                                                       ilg_bool fDisconnect = ILG_FALSE);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_clear_licenses(ilg_handle hConverter,
                                                             ilg_bool fDisconnect,
                                                             ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_scan(ilg_handle hConverter, ilg_bool fReset = ILG_FALSE,
                                             ilg_bool fForce = ILG_FALSE);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_scan(ilg_handle hConverter, ilg_bool fReset,
                                                   ilg_bool fForce, ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_controller_count(ilg_handle hConverter, size_t* pCount);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_controller_info(ilg_handle hConverter, size_t nIdx,
                                                            ilg_controller_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_converter_set_auto_scan(ilg_handle hConverter,
                                                      ilg_bool fEnable = ILG_TRUE,
                                                      ilg_bool fWait = ILG_FALSE);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_set_auto_scan(ilg_handle hConverter, ilg_bool fEnable,
                                                            ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_auto_scan(ilg_handle hConverter, ilg_bool* pEnabled);
 
ILGUARD_EXPORT ilg_status ilg_converter_set_firmware(ilg_handle hConverter, const void* pData,
                                                     size_t nSize);
 
ILGUARD_EXPORT ilg_status ilg_converter_begin_set_firmware(ilg_handle hConverter, const void* pData,
                                                           size_t nSize, ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_converter_get_controller(ilg_handle hConverter,
                                                       ilg_controller_model nModel, int nSn,
                                                       ilg_handle* pController);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_message_callback(
    ilg_handle hController, ilg_controller_message_callback pCallback, void* pUserData = nullptr);
 
ILGUARD_EXPORT ilg_status ilg_controller_enable_message_queue(ilg_handle hController,
                                                              ilg_bool fEnable = ILG_TRUE);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_message(ilg_handle hController,
                                                     ilg_controller_msg* pMsg,
                                                     const void** pMsgData, ilg_bool* pFound);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_options(ilg_handle hController,
                                                     const ilg_controller_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_options(ilg_handle hController,
                                                     ilg_controller_options* pOptions);
 
ILGUARD_EXPORT ilg_status ilg_controller_connect(ilg_handle hController,
                                                 ilg_bool fReconnect = ILG_FALSE);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_connect(ilg_handle hController, ilg_bool fReconnect,
                                                       ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_disconnect(ilg_handle hController);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_disconnect(ilg_handle hController,
                                                          ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_connection_status(ilg_handle hController,
                                                               ilg_connection_status* pStatus);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_info(ilg_handle hController,
                                                  ilg_controller_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_converter_info(ilg_handle hController,
                                                            ilg_converter_info* pInfo);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_converter(ilg_handle hController,
                                                       ilg_handle* pConverter);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_lines(ilg_handle hController, char* pBuf,
                                                    size_t* pSize);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_lines(ilg_handle hController,
                                                          ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_lines(ilg_handle hCommand, const char** ppLines);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_lock_times(ilg_handle hController, uint8_t nBankN,
                                                         uint16_t* pOpen, uint16_t* pLet,
                                                         uint16_t* pMax, ilg_bool* pBigTime);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_lock_times(ilg_handle hController,
                                                               uint8_t nBankN,
                                                               ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_lock_times(ilg_handle hCommand, uint16_t* pOpen,
                                                             uint16_t* pLet, uint16_t* pMax,
                                                             ilg_bool* pBigTime);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_lock_times(ilg_handle hController, uint8_t nBankN,
                                                          uint16_t nOpen, uint16_t nLet,
                                                          uint16_t nMax, ilg_bool fBigTime);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_lock_times(ilg_handle hController,
                                                                uint8_t nBankN, uint16_t nOpen,
                                                                uint16_t nLet, uint16_t nMax,
                                                                ilg_bool fBigTime,
                                                                ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_apb_time(ilg_handle hController, ilg_bool* pEnabled,
                                                       uint16_t* pMinutes);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_apb_time(ilg_handle hController,
                                                             ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_apb_time(ilg_handle hCommand, ilg_bool* pEnabled,
                                                           uint16_t* pMinutes);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_apb_time(ilg_handle hController, ilg_bool fEnabled,
                                                        uint16_t nMinutes);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_apb_time(ilg_handle hController,
                                                              ilg_bool fEnabled, uint16_t nMinutes,
                                                              ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_time_zones(ilg_handle hController, uint8_t nBankN,
                                                         size_t nIdx, ilg_time_zone* pBuf,
                                                         size_t nCount, size_t* pRead);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_time_zones(ilg_handle hController,
                                                               uint8_t nBankN, size_t nIdx,
                                                               size_t nCount, ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_time_zones(ilg_handle hCommand,
                                                             const ilg_time_zone** ppList,
                                                             size_t* pRead);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_time_zones(ilg_handle hController, uint8_t nBankN,
                                                          size_t nIdx, const ilg_time_zone* pTZs,
                                                          size_t nCount, size_t* pWritten);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_time_zones(ilg_handle hController,
                                                                uint8_t nBankN, size_t nIdx,
                                                                const ilg_time_zone* pTZs,
                                                                size_t nCount,
                                                                ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_write_time_zones(ilg_handle hCommand,
                                                              size_t* pWritten);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_mode_time_zones(ilg_handle hController, size_t nIdx,
                                                              ilg_mode_time_zone* pBuf,
                                                              size_t nCount);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_mode_time_zones(ilg_handle hController,
                                                                    size_t nIdx, size_t nCount,
                                                                    ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_mode_time_zones(ilg_handle hCommand,
                                                                  const ilg_mode_time_zone** ppList,
                                                                  size_t* pRead);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_mode_time_zones(ilg_handle hController, size_t nIdx,
                                                               const ilg_mode_time_zone* pTZs,
                                                               size_t nCount);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_mode_time_zones(ilg_handle hController,
                                                                     size_t nIdx,
                                                                     const ilg_mode_time_zone* pTZs,
                                                                     size_t nCount,
                                                                     ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_keys(ilg_handle hController, uint8_t nBankN,
                                                   size_t nIdx, ilg_key* pBuf, size_t nCount,
                                                   size_t* pRead = nullptr);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_keys(ilg_handle hController, uint8_t nBankN,
                                                         size_t nIdx, size_t nCount,
                                                         ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_keys(ilg_handle hCommand, const ilg_key** ppList,
                                                       size_t* pRead);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_keys(ilg_handle hController, uint8_t nBankN,
                                                    size_t nIdx, const ilg_key* pKeys,
                                                    size_t nCount, size_t* pWritten,
                                                    ilg_bool fSelected);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_keys(ilg_handle hController, uint8_t nBankN,
                                                          size_t nIdx, const ilg_key* pKeys,
                                                          size_t nCount, ilg_bool fSelected,
                                                          ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_write_keys(ilg_handle hCommand, size_t* pWritten);
 
ILGUARD_EXPORT ilg_status ilg_controller_erase_keys(ilg_handle hController, uint8_t nBankN,
                                                    size_t nIdx, size_t nCount, size_t* pErased);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_erase_keys(ilg_handle hController, uint8_t nBankN,
                                                          size_t nIdx, size_t nCount,
                                                          ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_erase_keys(ilg_handle hCommand, size_t* pErased);
 
ILGUARD_EXPORT ilg_status ilg_controller_erase_keys2(ilg_handle hController, uint8_t nBankN,
                                                     const size_t* pIdxs, size_t nCount,
                                                     size_t* pErased);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_erase_keys2(ilg_handle hController, uint8_t nBankN,
                                                           const size_t* pIdxs, size_t nCount,
                                                           ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_erase_keys2(ilg_handle hCommand, size_t* pErased);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_key_top_idx(ilg_handle hController, uint8_t nBankN,
                                                          ssize_t* pIdx);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_key_top_idx(ilg_handle hController,
                                                                uint8_t nBankN,
                                                                ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_key_top_idx(ilg_handle hCommand, ssize_t* pIdx);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_events(ilg_handle hController, size_t nIdx,
                                                     uint64_t* pBuf, size_t nCount,
                                                     size_t* pRead = nullptr);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_events(ilg_handle hController, size_t nIdx,
                                                           size_t nCount, ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_events(ilg_handle hCommand,
                                                         const uint64_t** ppList, size_t* pRead);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_event_read_idx(ilg_handle hController, size_t nIdx);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_event_read_idx(ilg_handle hController,
                                                                    size_t nIdx,
                                                                    ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_rtc_params(ilg_handle hController,
                                                         ilg_rtc_params* pParams);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_rtc_params(ilg_handle hController,
                                                               ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_rtc_params(ilg_handle hCommand,
                                                             ilg_rtc_params* pParams);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_rtc_params(ilg_handle hController,
                                                        ilg_rtc_params* pParams);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_extask_params(ilg_handle hController,
                                                            ilg_extask_params* pParams);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_extask_params(ilg_handle hController,
                                                                  ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_extask_params(ilg_handle hCommand,
                                                                ilg_extask_params* pParams);
 
ILGUARD_EXPORT ilg_status ilg_controller_get_extask_params(ilg_handle hController,
                                                           ilg_extask_params* pParams);
 
ILGUARD_EXPORT ilg_status ilg_controller_sync_clock(ilg_handle hController);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_sync_clock(ilg_handle hController,
                                                          ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_emergency_mode(ilg_handle hController,
                                                            ilg_bool fEnable);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_set_emergency_mode(ilg_handle hController,
                                                                  ilg_bool fEnable,
                                                                  ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_anticovid(ilg_handle hController, uint16_t* pMax8,
                                                        uint16_t* pCount8);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_anticovid(ilg_handle hController,
                                                              ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_anticovid(ilg_handle hCommand, uint16_t* pMax8,
                                                            uint16_t* pCount8);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_anticovid(ilg_handle hController,
                                                         const uint16_t* pMax8);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_anticovid(ilg_handle hController,
                                                               const uint16_t* pMax8,
                                                               ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_open_door(ilg_handle hController, ilg_bool fOut);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_open_door(ilg_handle hController, ilg_bool fOut,
                                                         ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_fire_mode(ilg_handle hController, ilg_bool fOn);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_set_fire_mode(ilg_handle hController, ilg_bool fOn,
                                                             ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_security_mode(ilg_handle hController, ilg_bool fOn);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_set_security_mode(ilg_handle hController,
                                                                 ilg_bool fOn,
                                                                 ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_alarm_mode(ilg_handle hController, ilg_bool fOn);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_set_alarm_mode(ilg_handle hController, ilg_bool fOn,
                                                              ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_ec_power(ilg_handle hController, ilg_bool fOn);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_set_ec_power(ilg_handle hController, ilg_bool fOn,
                                                            ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_fire_params(ilg_handle hController, uint8_t* pSrcMask,
                                                          uint8_t* pLimitT, uint8_t* pState,
                                                          uint8_t* pT);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_fire_params(ilg_handle hController,
                                                                ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_fire_params(ilg_handle hCommand,
                                                              uint8_t* pSrcMask, uint8_t* pLimitT,
                                                              uint8_t* pState, uint8_t* pT);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_fire_params(ilg_handle hController, uint8_t nSrcMask,
                                                           uint8_t nLimitT, uint8_t* pState,
                                                           uint8_t* pT);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_fire_params(ilg_handle hController,
                                                                 uint8_t nSrcMask, uint8_t nLimitT,
                                                                 ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_write_fire_params(ilg_handle hCommand, uint8_t* pState,
                                                               uint8_t* pT);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_security_params(ilg_handle hController,
                                                              uint8_t* pSrcMask, uint8_t* pTime,
                                                              uint8_t* pState);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_security_params(ilg_handle hController,
                                                                    ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_security_params(ilg_handle hCommand,
                                                                  uint8_t* pSrcMask, uint8_t* pTime,
                                                                  uint8_t* pState);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_security_params(ilg_handle hController,
                                                               uint8_t nSrcMask, uint8_t nTime,
                                                               uint8_t* pState);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_security_params(ilg_handle hController,
                                                                     uint8_t nSrcMask,
                                                                     uint8_t nTime,
                                                                     ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_write_security_params(ilg_handle hCommand,
                                                                   uint8_t* pState);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_ec_params(ilg_handle hController,
                                                        uint8_t* pPowerConfig, uint8_t* pDelay,
                                                        uint8_t* pState);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_ec_params(ilg_handle hController,
                                                              ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_ec_params(ilg_handle hCommand,
                                                            uint8_t* pPowerConfig, uint8_t* pDelay,
                                                            uint8_t* pState);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_mode(ilg_handle hController,
                                                    ilg_controller_mode nMode);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_mode(ilg_handle hController,
                                                          ilg_controller_mode nMode,
                                                          ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_mode(ilg_handle hController,
                                                   ilg_controller_mode* pMode, uint8_t* pFlags);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_mode(ilg_handle hController,
                                                         ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_mode(ilg_handle hCommand,
                                                       ilg_controller_mode* pMode, uint8_t* pFlags);
 
ILGUARD_EXPORT ilg_status ilg_controller_write_configuration(ilg_handle hController,
                                                             const void* pData, size_t nSize);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_write_configuration(ilg_handle hController,
                                                                   const void* pData, size_t nSize,
                                                                   ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_read_configuration(ilg_handle hController, uint8_t* pBuf,
                                                            size_t* pSize);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_read_configuration(ilg_handle hController,
                                                                  ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_end_read_configuration(ilg_handle hCommand,
                                                                const uint8_t** ppData,
                                                                size_t* pSize);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_network_address(ilg_handle hController,
                                                             uint8_t nAddress);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_set_network_address(ilg_handle hController,
                                                                   uint8_t nAddress,
                                                                   ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_set_firmware(ilg_handle hController, const void* pData,
                                                      size_t nSize);
 
ILGUARD_EXPORT ilg_status ilg_controller_begin_set_firmware(ilg_handle hController,
                                                            const void* pData, size_t nSize,
                                                            ilg_handle* pCommand);
 
ILGUARD_EXPORT ilg_status ilg_controller_decode_event_type(ilg_handle hController,
                                                           const uint64_t& nEvent,
                                                           ilg_event_format* pFormat,
                                                           ilg_event_type* pType);
 
ILGUARD_EXPORT ilg_status ilg_controller_decode_passage_event(ilg_handle hController,
                                                              const uint64_t& nEvent,
                                                              ilg_controller_time* pTime,
                                                              ilg_direction* pDirection,
                                                              uint8_t* pKeyBankN, ssize_t* pKeyIdx);
 
ILGUARD_EXPORT ilg_status ilg_controller_decode_time_event(ilg_handle hController,
                                                           const uint64_t& nEvent,
                                                           ilg_controller_time* pTime);
 
ILGUARD_EXPORT ilg_status ilg_controller_decode_controller_mode_event(
    ilg_handle hController, const uint64_t& nEvent, ilg_controller_time* pTime,
    ilg_controller_mode* pMode, uint8_t* pFlags, uint8_t* pTrigger);
 
ILGUARD_EXPORT ilg_status ilg_controller_decode_state_event(ilg_handle hController,
                                                            const uint64_t& nEvent,
                                                            ilg_controller_time* pTime,
                                                            uint8_t* pFlags, uint8_t* pTrigger);
 
ILGUARD_EXPORT ilg_status ilg_controller_decode_key_number(ilg_handle hController,
                                                           const uint64_t& nEvent,
                                                           ilg_key_number* pKeyNumber);
 
ILGUARD_EXPORT ilg_status ilg_command_cancel(ilg_handle hCommand);
 
ILGUARD_EXPORT ilg_status ilg_command_get_status(ilg_handle hCommand, ilg_status* pStatus);
 
ILGUARD_EXPORT ilg_status ilg_command_get_progress(ilg_handle hCommand, size_t* pCurrent,
                                                   size_t* pTotal);
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif  // ILGUARD_H_INCLUDED