ilreaders.h

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

 
#ifndef ILREADERS_H_INCLUDED
#define ILREADERS_H_INCLUDED
#include <stdint.h>  // для uint8_t
#include <string.h>  // для memcpy, memset и memcmp
 
#ifndef ILR_STATIC_DEFINE
#include <ilreaders/export_shared.h>
#else
#include <ilreaders/export_static.h>
#endif
 
// #define ILREADERS_LINKONREQUEST
 
#define ILR_VERSION_MAJOR 1
#define ILR_VERSION_MINOR 1
#define ILR_VERSION_PATCH 3
#define ILR_VERSION \
    ((ILR_VERSION_MAJOR << 24) | (ILR_VERSION_MINOR << 16) | (ILR_VERSION_PATCH << 8) | 0xC0)
 
#define ILR_VERSION_GET_MAJOR(v) ((v) >> 24)
#define ILR_VERSION_GET_MINOR(v) (((v) >> 16) & 0xff)
#define ILR_VERSION_GET_PATCH(v) (((v) >> 8) & 0xff)
#define ILR_AUTOALLOCATE 0xffffffff
 
typedef void* ilr_handle;
 
typedef enum : int {
    ILR_FALSE,  
    ILR_TRUE  
} ilr_bool;
 
typedef enum {
    ILR_OK = 0,
    ILR_E_FAIL,
    ILR_E_PENDING,
    ILR_E_BOUNDS,
    ILR_E_NOTIMPL,
    ILR_E_POINTER,
    ILR_E_ABORT,
    ILR_E_HANDLE,
    ILR_E_OUTOFMEMORY,
    ILR_E_INVALIDARG,
    ILR_E_WRONG_SDK_VERSION,
    ILR_E_NOT_INITIALIZED,
    ILR_E_OUT_OF_RESOURCES,
    ILR_E_BUFFER_TOO_SMALL,
    ILR_E_BLOCKING_CALL_NOT_ALLOWED,
    ILR_E_PORT_NOT_EXIST,
    ILR_E_PORT_ACCESS_DENIED,
    ILR_E_PORT_OPEN_FAILED,
    ILR_E_CONNECTION_ERROR,
    ILR_E_CONNECTION_DOWN,
    ILR_E_REQUEST_TIMEOUT,
    ILR_E_BAD_RESPONSE,
    ILR_E_SCARD_ERROR,
    ILR_E_READER_ERROR,
    ILR_E_NO_CARD,
    ILR_E_CARD_NACK,
    ILR_E_CARD_AUTH,
    ILR_E_MIFARE_ADDRESS,
    ILR_E_MIFARE_VALUE,
    ILR_E_CARD_PAGE_LOCK,
    ILR_E_WRITE_T57,
    ILR_E_PORT_BUSY,
    ILR_STATUS_SIZE
} ilr_status;
 
#define ILR_SUCCEEDED(status) ((status) == ILR_OK)
 
#define ILR_FAILED(status) ((status) != ILR_OK)
 
typedef enum {
    ILR_READER_MODEL_UNKNOWN,
    ILR_READER_MODEL_Z2_RDALL,
    ILR_READER_MODEL_Z2_MF,
    ILR_READER_MODEL_Z2_MFI,
    ILR_READER_MODEL_Z2_E_HTZ_RF,
    ILR_READER_MODEL_Z1_N_Z,
    ILR_READER_MODEL_Z2_E_HT_HOTEL,
    ILR_READER_MODEL_MATRIX3_RDALL,
    ILR_READER_MODEL_MATRIX3_NET,
    ILR_READER_MODEL_CP_Z2_MFI,
    ILR_READER_MODEL_MATRIX5_E_S_RF,
    ILR_READER_MODEL_MATRIX6,
    ILR_READER_MODEL_Z2_MF_CCID,
    ILR_READER_MODEL_SIZE
} ilr_reader_model;
 
typedef enum {
    ILR_PORT_TYPE_UNKNOWN,
    ILR_PORT_TYPE_COMPORT,
    ILR_PORT_TYPE_CCID,
    ILR_PORT_TYPE_SERVER,
    ILR_PORT_TYPE_CLIENT,
    ILR_PORT_TYPE_PROXY,
    ILR_PORT_TYPE_SIZE
} ilr_port_type;
 
typedef enum {
    ILR_CARD_UNKNOWN,     
    ILR_CARD_EM_MARINE,   
    ILR_CARD_HID,         
    ILR_CARD_ICODE,       
    ILR_CARD_COD433,      
    ILR_CARD_COD433_FIX,  
    ILR_CARD_CAME433,     
    ILR_CARD_DALLAS,      
    ILR_CARD_TEMIC,       
 
    ILR_CARD_MF_ULTRALIGHT,    
    ILR_CARD_MF_ULTRALIGHT_C,  
    ILR_CARD_MF_MINI,          
    ILR_CARD_MF_CLASSIC_1K,    
    ILR_CARD_MF_CLASSIC_2K,    
    ILR_CARD_MF_CLASSIC_4K,    
    ILR_CARD_MF_PLUS,          
    ILR_CARD_MF_PLUS_1K,       
    ILR_CARD_MF_PLUS_2K,       
    ILR_CARD_MF_PLUS_4K,       
    ILR_CARD_SMART_MX_MF1K,    
    ILR_CARD_SMART_MX_MF4K,    
    ILR_CARD_MF_DESFIRE,       
    ILR_CARD_MF_PROX,          
    ILR_CARD_TYPE_SIZE         
} ilr_card_type;
 
typedef struct {
    ilr_port_type nPortType;
    const char* pszPortName;
    const char* pszConnect;
    ilr_reader_model nModel;
    int nSn;
    uint32_t nFwVersion;
    int64_t nFwBuildDate;
    ilr_status nError;
} ilr_reader_info;
 
typedef enum {
    ILR_LOG_LEVEL_NONE,
 
    ILR_LOG_LEVEL_ERROR,
 
    ILR_LOG_LEVEL_WARNING,
 
    ILR_LOG_LEVEL_INFO,
 
    ILR_LOG_LEVEL_DEBUG,
    ILR_LOG_LEVEL_SIZE
} ilr_log_level;
 
typedef void (*ilr_logging_callback)(ilr_log_level nLevel, const char* pContext,
                                     const char* pMessage, void* pUserData);
 
typedef struct {
    ilr_bool fTwoStopBits;
    int nRequestTimeout;
    int nRequestAttempts;
} ilr_options;
 
typedef ilr_bool (*ilr_filter_port_callback)(ilr_port_type nPortType, const char* pszPortName,
                                             void* pUserData);
 
typedef enum {
    ILR_SEARCH_MSG_COMMAND_FINISH,
    ILR_SEARCH_MSG_READER_FOUND,
    ILR_SEARCH_MSG_READER_LOST,
    ILR_SEARCH_MSG_LIST_CHANGED
} ilr_search_msg;
 
typedef void (*ilr_search_message_callback)(ilr_search_msg nMsg, const void* pMsgData,
                                            void* pUserData);
 
typedef enum : uint32_t {
    ILR_READER_ILUSB = (1 << 0),
    ILR_READER_TPUSB = (1 << 1),
    ILR_READER_SERVER = (1 << 2),
    ILR_READER_CLIENT = (1 << 3),
    ILR_READER_CCID = (1 << 4)
} ilr_reader_types;
 
typedef struct {
    uint32_t nReaderTypes;
    int nOpenPortPeriod;
    int nPollPeriod;
    int nUdpScanPeriod;
    int nUdpRequestTimeout;
    int nUdpRequestAttempts;
    int nOpenListenerPeriod;
    int nAcceptTimeout;
} ilr_search_options;
 
typedef enum {
    ILR_READER_MSG_COMMAND_FINISH,
    ILR_READER_MSG_CONNECTION_CHANGED,
    ILR_READER_MSG_CARD_FOUND,
    ILR_READER_MSG_CARD_LOST
} ilr_reader_msg;
 
typedef void (*ilr_reader_message_callback)(ilr_reader_msg nMsg, const void* pMsgData,
                                            void* pUserData);
 
typedef enum {
    ILR_CONNECTION_DISCONNECTED,  
    ILR_CONNECTION_CONNECTED,     
    ILR_CONNECTION_CONNECTING     
} ilr_connection_status;
 
typedef struct __attribute__((packed)) {
    uint8_t nLength;  
 
    union {
        uint8_t aBytes[15];  
 
        struct __attribute__((packed)) {
            uint16_t nNumber;
            uint8_t nSeries;
            uint16_t nFacility;
        } em_marine;
    };
} ilr_card_uid;
 
typedef enum : int8_t {
    ILR_MF_PLUS_SL_UNKNOWN = -1,  
    ILR_MF_PLUS_SL_SL0,           
    ILR_MF_PLUS_SL_SL1,           
    ILR_MF_PLUS_SL_SL2,           
    ILR_MF_PLUS_SL_SL3            
} ilr_mf_plus_sl;
 
typedef enum : uint8_t {
    ILR_MF_PLUS_UNKNOWN,   
    ILR_MF_PLUS_S,         
    ILR_MF_PLUS_X,         
    ILR_MF_PLUS_SE,        
    ILR_MF_PLUS_EV1,       
    ILR_MF_PLUS_EV2,       
    ILR_MF_PLUS_TYPE_SIZE  
} ilr_mf_plus_type;
 
typedef struct {
    ilr_card_type nType;       
    ilr_card_uid rUID;         
    uint32_t nMemSize;         
    ilr_mf_plus_sl nSL;        
    ilr_mf_plus_type nMpType;  
    ilr_card_type nType2;      
    ilr_card_uid rUID2;        
} ilr_card_info;
 
typedef int64_t ilr_mf_classic_key;
 
typedef struct {
    union {
        uint8_t a[16];  
 
        struct {
            uint64_t lo;  
            uint64_t hi;  
        } ll;
    };
} ilr_mf_plus_key;
 
typedef struct {
    uint8_t a[16] = {0};  
} ilr_mf_block_data;
 
typedef enum : uint32_t {
    ILR_RWCT_F_TEMIC = (1 << 0),          
    ILR_RWCT_F_MF_ULTRALIGHT = (1 << 1),  
    ILR_RWCT_F_MF_CLASSIC = (1 << 2),     
    ILR_RWCT_F_MF_PLUS_SL0 = (1 << 3),    
    ILR_RWCT_F_MF_PLUS_SL3 = (1 << 4),    
    ILR_RWCT_F_MF_PLUS = (1 << 5)         
} ilr_rwcard_type_flags;
 
#define MAKE_TEMIC_SCAN_PARAM(type, speed) (int)(((uint)((speed)&0xff) << 8) | ((type)&0xff))
#define TYPE_FROM_TEMIC_SCAN_PARAM(param) (uint8_t)((param)&0xff)
#define SPEED_FROM_TEMIC_SCAN_PARAM(param) (uint8_t)(((uint)(param) >> 8) & 0xff)
 
typedef struct {
    ilr_reader_model nConnectModel;
 
    uint32_t nHoldCardTypes;
 
    int nReconnectPeriod;
} ilr_reader_options;
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef ILREADERS_LINKONREQUEST
 
ILREADERS_EXPORT uint32_t ilr_get_version();
 
ILREADERS_EXPORT const char* ilr_get_error_text(ilr_status nErrorCode);
 
ILREADERS_EXPORT ilr_status ilr_set_log_level(ilr_log_level nLevel);
 
ILREADERS_EXPORT ilr_status ilr_set_log_callback(ilr_logging_callback pCallback,
                                                 void* pUserData = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_free_memory(void* p);
 
inline bool ilr_check_version() {
    auto v = ilr_get_version();
    return ((((v >> 24) & 0xff) == ILR_VERSION_MAJOR) &&
            ((int)((v >> 16) & 0xff) >= ILR_VERSION_MINOR));
}
 
ILREADERS_EXPORT ilr_status ilr_init(uint32_t nVersionRequested = ILR_VERSION);
 
ILREADERS_EXPORT ilr_status ilr_cleanup();
 
ILREADERS_EXPORT ilr_status ilr_close_handle(ilr_handle h);
 
ILREADERS_EXPORT ilr_status ilr_clone_handle(ilr_handle h, ilr_handle* pNewHandle);
 
ILREADERS_EXPORT ilr_status ilr_set_filter_port_callback(ilr_filter_port_callback pCallback,
                                                         void* pUserData = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_set_options(const ilr_options* pOptions);
 
ILREADERS_EXPORT ilr_status ilr_get_options(ilr_options* pOptions);
 
ILREADERS_EXPORT ilr_status ilr_get_search(ilr_handle* pSearch);
 
ILREADERS_EXPORT ilr_status ilr_get_reader(ilr_port_type nPortType, const char* pszPortName,
                                           ilr_handle* pReader);
 
ILREADERS_EXPORT ilr_status ilr_search_set_message_callback(ilr_handle hSearch,
                                                            ilr_search_message_callback pCallback,
                                                            void* pUserData = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_search_enable_message_queue(ilr_handle hSearch,
                                                            ilr_bool fEnable = ILR_TRUE);
 
ILREADERS_EXPORT ilr_status ilr_search_get_message(ilr_handle hSearch, ilr_search_msg* pMsg,
                                                   const void** pMsgData, ilr_bool* pFound);
 
ILREADERS_EXPORT ilr_status ilr_search_set_options(ilr_handle hSearch,
                                                   const ilr_search_options* pOptions);
 
ILREADERS_EXPORT ilr_status ilr_search_get_options(ilr_handle hSearch,
                                                   ilr_search_options* pOptions);
 
ILREADERS_EXPORT ilr_status ilr_search_set_listen_ports(ilr_handle hSearch, const uint16_t* pPorts,
                                                        size_t nCount);
 
ILREADERS_EXPORT ilr_status ilr_search_get_listen_ports(ilr_handle hSearch, uint16_t* pBuf,
                                                        size_t* pSize);
 
ILREADERS_EXPORT ilr_status ilr_search_get_listen_status(ilr_handle hSearch, uint16_t nTcpPort,
                                                         ilr_status* pStatus);
 
ILREADERS_EXPORT ilr_status ilr_search_scan(ilr_handle hSearch, ilr_bool fReset = ILR_FALSE);
 
ILREADERS_EXPORT ilr_status ilr_search_begin_scan(ilr_handle hSearch, ilr_bool fReset,
                                                  ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_search_get_reader_count(ilr_handle hSearch, size_t* pCount);
 
ILREADERS_EXPORT ilr_status ilr_search_get_reader_info(ilr_handle hSearch, size_t nIdx,
                                                       ilr_reader_info* pInfo);
 
ILREADERS_EXPORT ilr_status ilr_search_set_auto_scan(ilr_handle hSearch,
                                                     ilr_bool fEnable = ILR_TRUE,
                                                     ilr_bool fWait = ILR_TRUE);
 
ILREADERS_EXPORT ilr_status ilr_search_begin_set_auto_scan(ilr_handle hSearch, ilr_bool fEnable,
                                                           ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_search_get_auto_scan(ilr_handle hSearch, ilr_bool* pEnabled);
 
ILREADERS_EXPORT ilr_status ilr_search_open_port(ilr_handle hSearch, ilr_port_type nPortType,
                                                 const char* pszPortName, ilr_reader_info* pInfo,
                                                 int* pPort);
 
ILREADERS_EXPORT ilr_status ilr_search_begin_open_port(ilr_handle hSearch, ilr_port_type nPortType,
                                                       const char* pszPortName,
                                                       ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_search_end_open_port(ilr_handle hCommand, int* pPortFD,
                                                     ilr_reader_info* pInfo);
 
ILREADERS_EXPORT ilr_status ilr_search_close_port(ilr_handle hSearch, ilr_port_type nPortType,
                                                  const char* pszPortName, int hPort);
 
ILREADERS_EXPORT ilr_status ilr_search_begin_close_port(ilr_handle hSearch, ilr_port_type nPortType,
                                                        const char* pszPortName, int hPortFD,
                                                        ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_set_message_callback(ilr_handle hReader,
                                                            ilr_reader_message_callback pCallback,
                                                            void* pUserData = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_enable_message_queue(ilr_handle hReader,
                                                            ilr_bool fEnable = ILR_TRUE);
 
ILREADERS_EXPORT ilr_status ilr_reader_get_message(ilr_handle hReader, ilr_reader_msg* pMsg,
                                                   const void** pMsgData, ilr_bool* pFound);
 
ILREADERS_EXPORT ilr_status ilr_reader_set_options(ilr_handle hReader,
                                                   const ilr_reader_options* pOptions);
 
ILREADERS_EXPORT ilr_status ilr_reader_get_options(ilr_handle hReader,
                                                   ilr_reader_options* pOptions);
 
ILREADERS_EXPORT ilr_status ilr_reader_connect(ilr_handle hReader, ilr_bool fReconnect = ILR_FALSE);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_connect(ilr_handle hReader, ilr_bool fReconnect,
                                                     ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_disconnect(ilr_handle hReader);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_disconnect(ilr_handle hReader, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_get_connection_status(ilr_handle hReader,
                                                             ilr_connection_status* pStatus);
 
ILREADERS_EXPORT ilr_status ilr_reader_get_info(ilr_handle hReader, ilr_reader_info* pInfo);
 
ILREADERS_EXPORT ilr_status ilr_reader_scan(ilr_handle hReader, ilr_bool fReset = ILR_FALSE,
                                            ilr_bool fPowerOff = ILR_TRUE);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_scan(ilr_handle hReader, ilr_bool fReset,
                                                  ilr_bool fPowerOff, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_get_card_info(ilr_handle hReader, ilr_card_info* pInfo);
 
ILREADERS_EXPORT ilr_status ilr_reader_set_auto_scan(ilr_handle hReader,
                                                     ilr_bool fEnable = ILR_TRUE,
                                                     ilr_bool fWait = ILR_TRUE);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_set_auto_scan(ilr_handle hReader, ilr_bool fEnable,
                                                           ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_get_auto_scan(ilr_handle hReader, ilr_bool* pEnabled);
 
ILREADERS_EXPORT ilr_status ilr_reader_read_mf_ultralight(ilr_handle hReader, size_t nPageIdx,
                                                          uint32_t* pBuf, size_t nPageCount,
                                                          size_t* pRead = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_read_mf_ultralight(ilr_handle hReader, size_t nPageIdx,
                                                                size_t nPageCount,
                                                                ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_read_mf_ultralight(ilr_handle hCommand,
                                                              const uint32_t** ppList,
                                                              size_t* pRead);
 
ILREADERS_EXPORT ilr_status ilr_reader_write_mf_ultralight(ilr_handle hReader, size_t nPageIdx,
                                                           const uint32_t* pData, size_t nPageCount,
                                                           size_t* pWritten = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_write_mf_ultralight(ilr_handle hReader,
                                                                 size_t nPageIdx,
                                                                 const uint32_t* pData,
                                                                 size_t nPageCount,
                                                                 ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_write_mf_ultralight(ilr_handle hCommand,
                                                               size_t* pWritten);
 
ILREADERS_EXPORT ilr_status ilr_reader_load_mf_ckey(ilr_handle hReader,
                                                    const ilr_mf_classic_key& nKey);
 
ILREADERS_EXPORT ilr_status ilr_reader_load_mf_pkey(ilr_handle hReader,
                                                    const ilr_mf_plus_key& rKey);
 
ILREADERS_EXPORT ilr_status ilr_reader_auth_mf_card(ilr_handle hReader, size_t nAddress,
                                                    ilr_bool fKeyB, ilr_bool* pAuthOk);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_auth_mf_card(ilr_handle hReader, size_t nAddress,
                                                          ilr_bool fKeyB, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_auth_mf_card(ilr_handle hCommand, ilr_bool* pAuthOk);
 
ILREADERS_EXPORT ilr_status ilr_reader_auth_mf_card2(ilr_handle hReader, size_t nAddress,
                                                     ilr_bool fKeyB, uint32_t nKeys = 0xFFFF,
                                                     int* pFoundIdx = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_auth_mf_card2(ilr_handle hReader, size_t nAddress,
                                                           ilr_bool fKeyB, uint32_t nKeys,
                                                           ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_auth_mf_card2(ilr_handle hCommand, int* pFoundIdx);
 
ILREADERS_EXPORT ilr_status ilr_reader_read_mf_classic(ilr_handle hReader, size_t nBlockIdx,
                                                       ilr_mf_block_data* pBuf, size_t nBlockCount,
                                                       size_t* pRead = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_read_mf_classic(ilr_handle hReader, size_t nBlockIdx,
                                                             size_t nBlockCount,
                                                             ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_read_mf_classic(ilr_handle hCommand,
                                                           const ilr_mf_block_data** ppList,
                                                           size_t* pRead);
 
ILREADERS_EXPORT ilr_status ilr_reader_write_mf_classic(ilr_handle hReader, size_t nBlockIdx,
                                                        const ilr_mf_block_data* pData,
                                                        size_t nBlockCount,
                                                        size_t* pWritten = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_write_mf_classic(ilr_handle hReader, size_t nBlockIdx,
                                                              const ilr_mf_block_data* pData,
                                                              size_t nBlockCount,
                                                              ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_write_mf_classic(ilr_handle hCommand, size_t* pWritten);
 
ILREADERS_EXPORT ilr_status ilr_reader_read_mf_plus(ilr_handle hReader, size_t nAddress,
                                                    ilr_mf_block_data* pBuf, size_t nBlockCount,
                                                    ilr_bool fOpenText = ILR_TRUE,
                                                    size_t* pRead = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_read_mf_plus(ilr_handle hReader, size_t nAddress,
                                                          size_t nBlockCount, ilr_bool fOpenText,
                                                          ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_read_mf_plus(ilr_handle hCommand,
                                                        const ilr_mf_block_data** ppList,
                                                        size_t* pRead);
 
ILREADERS_EXPORT ilr_status ilr_reader_write_mf_plus(ilr_handle hReader, size_t nAddress,
                                                     const ilr_mf_block_data* pData,
                                                     size_t nBlockCount,
                                                     ilr_bool fOpenText = ILR_TRUE,
                                                     size_t* pWritten = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_write_mf_plus(ilr_handle hReader, size_t nAddress,
                                                           const ilr_mf_block_data* pData,
                                                           size_t nBlockCount, ilr_bool fOpenText,
                                                           ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_write_mf_plus(ilr_handle hCommand, size_t* pWritten);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_increment(ilr_handle hReader, size_t nBlockIdx,
                                                    uint32_t nValue);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_mf_increment(ilr_handle hReader, size_t nBlockIdx,
                                                          uint32_t nValue, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_decrement(ilr_handle hReader, size_t nBlockIdx,
                                                    uint32_t nValue);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_mf_decrement(ilr_handle hReader, size_t nBlockIdx,
                                                          uint32_t nValue, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_transfer(ilr_handle hReader, size_t nBlockIdx);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_mf_transfer(ilr_handle hReader, size_t nBlockIdx,
                                                         ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_restore(ilr_handle hReader, size_t nBlockIdx);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_mf_restore(ilr_handle hReader, size_t nBlockIdx,
                                                        ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_power_off(ilr_handle hReader);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_ras(ilr_handle hReader, ilr_bool fWakeUp, uint8_t* pSAK,
                                              uint16_t* pATQ, ilr_card_uid* pUID, ilr_bool* pFound);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_rr(ilr_handle hReader, ilr_bool fWakeUp,
                                             const ilr_card_uid& rUID, ilr_bool* pFound);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_halt(ilr_handle hReader);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_rats(ilr_handle hReader, uint8_t* pAtsBuf = nullptr,
                                               size_t* pSize = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_write_perso(ilr_handle hReader, uint32_t nAddress,
                                                      const ilr_mf_plus_key& rKey);
 
ILREADERS_EXPORT ilr_status ilr_reader_mf_commit_perso(ilr_handle hReader);
 
ILREADERS_EXPORT ilr_status ilr_reader_write_mf_ckey(ilr_handle hReader, size_t nIdx,
                                                     ilr_bool fKeyB,
                                                     const ilr_mf_classic_key* pKeys, size_t nCount,
                                                     size_t* pWritten = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_write_mf_ckey(ilr_handle hReader, size_t nIdx,
                                                           ilr_bool fKeyB,
                                                           const ilr_mf_classic_key* pKeys,
                                                           size_t nCount, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_write_mf_ckey(ilr_handle hCommand, size_t* pWritten);
 
ILREADERS_EXPORT ilr_status ilr_reader_write_mf_pkey(ilr_handle hReader, size_t nIdx,
                                                     ilr_bool fKeyB, const ilr_mf_plus_key* pKeys,
                                                     size_t nCount, size_t* pWritten = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_write_mf_pkey(ilr_handle hReader, size_t nIdx,
                                                           ilr_bool fKeyB,
                                                           const ilr_mf_plus_key* pKeys,
                                                           size_t nCount, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_write_mf_pkey(ilr_handle hCommand, size_t* pWritten);
 
ILREADERS_EXPORT ilr_status ilr_reader_load_temic_password(ilr_handle hReader,
                                                           const int64_t& nPassword);
 
ILREADERS_EXPORT ilr_status ilr_reader_scan_temic(ilr_handle hReader, int nScanParam = -1);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_scan_temic(ilr_handle hReader, int nScanParam,
                                                        ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_set_scan_temic(ilr_handle hReader,
                                                      ilr_bool fEnable = ILR_TRUE);
 
ILREADERS_EXPORT ilr_status ilr_reader_get_scan_temic(ilr_handle hReader, ilr_bool* pEnable);
 
ILREADERS_EXPORT ilr_status ilr_reader_read_temic(ilr_handle hReader, size_t nBlockIdx,
                                                  uint32_t* pBuf, size_t nBlockCount,
                                                  int nScanParam = -1, size_t* pRead = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_read_temic(ilr_handle hReader, size_t nBlockIdx,
                                                        size_t nBlockCount, int nScanParam,
                                                        ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_read_temic(ilr_handle hCommand, const uint** ppList,
                                                      size_t* pRead);
 
ILREADERS_EXPORT ilr_status ilr_reader_write_temic(ilr_handle hReader, size_t nBlockIdx,
                                                   const uint32_t* pData, size_t nBlockCount,
                                                   ilr_bool fLock = ILR_FALSE, int nScanParam = -1,
                                                   size_t* pWritten = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_write_temic(ilr_handle hReader, size_t nBlockIdx,
                                                         const uint32_t* pData, size_t nBlockCount,
                                                         ilr_bool fLock, int nScanParam,
                                                         ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_end_write_temic(ilr_handle hCommand, size_t* pWritten);
 
ILREADERS_EXPORT ilr_status ilr_reader_reset_temic(ilr_handle hReader, ilr_bool fWait = ILR_TRUE);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_reset_temic(ilr_handle hReader, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_reader_begin_reset_temic(ilr_handle hReader, ilr_handle* pCommand);
 
ILREADERS_EXPORT ilr_status ilr_encode_temic_emmarine(const ilr_card_uid& rUID, uint32_t* pBuf3,
                                                      size_t nBlockCount);
 
ILREADERS_EXPORT ilr_status ilr_decode_temic_emmarine(const uint32_t* pData3, size_t nBlockCount,
                                                      ilr_card_uid* pUID,
                                                      ilr_bool* pConfigOk = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_encode_temic_hid(const ilr_card_uid& rUID, uint32_t* pBuf4,
                                                 size_t nBlockCount, int nWiegand);
 
ILREADERS_EXPORT ilr_status ilr_decode_temic_hid(const uint32_t* pData4, size_t nBlockCount,
                                                 ilr_card_uid* pUID, int* pWiegand,
                                                 ilr_bool* pConfigOk = nullptr);
 
ILREADERS_EXPORT ilr_status ilr_command_cancel(ilr_handle hCommand);
 
ILREADERS_EXPORT ilr_status ilr_command_get_status(ilr_handle hCommand, ilr_status* pStatus);
 
ILREADERS_EXPORT ilr_status ilr_command_get_progress(ilr_handle hCommand, size_t* pCurrent,
                                                     size_t* pTotal);
 
#endif  // !ILREADERS_LINKONREQUEST
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif  // ILREADERS_H_INCLUDED