E:/new_work/branches/ss_v2.0/include_out/ss_lm_runtime.h

浏览该文件的文档.

#ifndef __SS_LM_RUMTIME_H__
#define __SS_LM_RUMTIME_H__
#include "ss_define.h"
#include "ss_error.h"

#ifdef  _MSC_VER
#pragma comment(linker, "/defaultlib:ws2_32.lib")
#pragma comment(linker, "/defaultlib:iphlpapi.lib")
#pragma comment(linker, "/defaultlib:psapi.lib")
#pragma comment(linker, "/defaultlib:Shlwapi.lib")
#pragma comment(lib, "rpcrt4.lib")


#if _MSC_VER >= 1900   // 1900是VS2015的版本号，解决静态库在VS2015下编译失败的问题
#pragma comment(linker, "/defaultlib:legacy_stdio_definitions.lib")
#endif  // MSC_VER

#endif//???

#define LED_COLOR_BLUE      0

#define LED_COLOR_RED       1

#define LED_STATE_CLOSE     0

#define LED_STATE_OPEN      1

#define LED_STATE_SHRINK    2

typedef SS_UINT32 (SSAPI *SS_CALL_BACK)(SS_UINT32   message,void*       wparam,void*       lparam);
    
//============================================================
//   Virbox许可服务 回调消息 message 类型
//============================================================
#define SS_ANTI_INFORMATION         0x0101

#define SS_ANTI_WARNING             0x0102

#define SS_ANTI_EXCEPTION           0x0103

#define SS_ANTI_IDLE                0x0104

#define SS_MSG_SERVICE_START        0x0200

#define SS_MSG_SERVICE_STOP         0x0201

#define SS_MSG_LOCK_AVAILABLE       0x0202

#define SS_MSG_LOCK_UNAVAILABLE     0x0203


//============================================================
//   回调消息类型：警告类型SS_ANTI_WARNING的值 wparam 参数
//============================================================
#define SS_ANTI_PATCH_INJECT        0x0201

#define SS_ANTI_MODULE_INVALID      0x0202

#define SS_ANTI_ATTACH_FOUND        0x0203

#define SS_ANTI_THREAD_INVALID      0x0204

#define SS_ANTI_THREAD_ERROR        0x0205

#define SS_ANTI_CRC_ERROR           0x0206

#define SS_ANTI_DEBUGGER_FOUND      0x0207
//=============================================================

#define SLM_FIXTIME_RAND_LENGTH     8

#define SLM_CALLBACK_VERSION02      0x02

#define  SLM_MEM_MAX_SIZE           2048

#define SLM_MAX_INPUT_SIZE          1758

#define SLM_MAX_OUTPUT_SIZE         1758

#define SLM_MAX_USER_CRYPT_SIZE     1520

#define SLM_MAX_USER_DATA_SIZE      2048

#define SLM_MAX_WRITE_SIZE          1904

#define SLM_VERIFY_DEVICE_PREFIX    "SENSELOCK"

#define SLM_VERIFY_DATA_SIZE        41

#define SLM_LOCK_SN_LENGTH          16

#define SLM_DEVELOPER_ID_SIZE       8

#define SLM_MAX_SERVER_NAME         32

#define SLM_MAX_ACCESS_TOKEN_LENGTH 64

#define SLM_MAX_CLOUD_SERVER_LENGTH 100

#define SLM_SNIPPET_SEED_LENGTH     32

#define SLM_DEV_PASSWORD_LENGTH     16

#define SLM_CLOUD_MAX_USER_GUID_SIZE            128 

#define SLM_GUID_LENGTH                     16  

#define SLM_FILE_TYPE_BINARY                    0

#define SLM_FILE_TYPE_EXECUTIVE                 1

#define SLM_FILE_TYPE_KEY                       2

#define SLM_FILE_PRIVILEGE_FLAG_READ            0x01

#define SLM_FILE_PRIVILEGE_FLAG_WRITE           0x02

#define SLM_FILE_PRIVILEGE_FLAG_USE             0x04

#define SLM_FILE_PRIVILEGE_FLAG_UPDATE          0x08

#define SLM_FILE_PRIVILEGE_FLAG_ENTRY_READ      0x10

#define SLM_FILE_PRIVILEGE_FLAG_ENTRY_WRITE     0x20

#define SLM_FILE_PRIVILEGE_FLAG_ENTRY_USE       0x40

#define SLM_FILE_PRIVILEGE_FLAG_ENTRY_UPDATE    0x80



#define SLM_LOGIN_MODE_AUTO                     0x0000

#define SLM_LOGIN_MODE_LOCAL_DONGLE             0x0001

#define SLM_LOGIN_MODE_REMOTE_DONGLE            0x0002

#define SLM_LOGIN_MODE_CLOUD                    0x0004

#define SLM_LOGIN_MODE_LOCAL_SLOCK              0x0008

#define SLM_LOGIN_MODE_REMOTE_SLOCK             0x0010

#define SLM_LOGIN_FLAG_FIND_ALL         0x0001    

#define SLM_LOGIN_FLAG_VERSION          0x0004

#define SLM_LOGIN_FLAG_LOCKSN           0x0008

#define SLM_LOGIN_FLAG_SERVER           0x0010

#define SLM_LOGIN_FLAG_SNIPPET          0x0020


#define LANGUAGE_CHINESE_ASCII                  0x0001

#define LANGUAGE_ENGLISH_ASCII                  0x0002

#define LANGUAGE_TRADITIONAL_CHINESE_ASCII      0x0003

#define SLM_INIT_FLAG_NOTIFY            0x01

#define SLM_MAC_SIZE                    6

#define SLM_MAX_CPU_INFO_SIZE           128

#define SLM_MAX_BIOS_INFO_SIZE          128

#define SLM_MAX_SESSION_ID_SIZE         32


typedef unsigned int SLM_HANDLE_INDEX; 

typedef enum _INFO_TYPE 
{
    LOCK_INFO = 1,
    SESSION_INFO = 2,
    LICENSE_INFO  = 3,
    FILE_LIST  = 4
} INFO_TYPE;

typedef enum _LIC_USER_DATA_TYPE 
{
    ROM = 0,     
    RAW = 1,
    PUB = 2
} LIC_USER_DATA_TYPE;

typedef enum _ENUM_DESC_TYPE 
{
    ENUM_DESC_LOCAL_DONGLE = 0,
    ENUM_DESC_REMOTE_DONGLE = 1,
    ENUM_DESC_CLOUD = 2,
    ENUM_DESC_SMART_OFFLINE = 3,
    ENUM_DESC_LOCAL_SLOCK = 4,
    ENUM_DESC_REMOTE_SLOCK = 5,
} ENUM_DESV_TYPE;

typedef struct _ST_LED_CONTROL 
{
    SS_UINT32   index;
    SS_UINT32   state;
    SS_UINT32   interval;   
} ST_LED_CONTROL;

typedef struct _ST_INIT_PARAM 
{
    SS_UINT32       version;
    SS_UINT32       flag;
    SS_CALL_BACK    pfn;
    SS_UINT32       timeout;
    SS_BYTE         password[SLM_DEV_PASSWORD_LENGTH];
} ST_INIT_PARAM;

typedef struct _ST_LOGIN_PARAM
{ 
    SS_UINT32       size;
    SS_UINT32       license_id;
    SS_UINT32       timeout;
    SS_UINT32       login_mode;
    SS_UINT32       login_flag;
    SS_BYTE         sn[SLM_LOCK_SN_LENGTH];
    SS_CHAR         server[SLM_MAX_SERVER_NAME];
    SS_CHAR         access_token[SLM_MAX_ACCESS_TOKEN_LENGTH];
    SS_CHAR         cloud_server[SLM_MAX_CLOUD_SERVER_LENGTH];
    SS_BYTE         snippet_seed[SLM_SNIPPET_SEED_LENGTH];
    SS_CHAR         user_guid[SLM_CLOUD_MAX_USER_GUID_SIZE];
} ST_LOGIN_PARAM;

typedef struct _ST_LOCK_INFO 
{
    SS_UINT32           size;      
    SS_UINT8            device_type;        
    SS_UINT8            device_mode;    
    SS_UINT16           res;             
    SS_UINT8            lmfirm_version[4];  
    SS_UINT32           h5firm_version;   
    SS_UINT32           hardware_version;   
    SS_UINT32           manufacture_date;   
    SS_UINT32           total_space;        
    SS_UINT32           available_space;    
    SS_UINT32           protocol;        
    SS_UINT32           slave_addr;       
    SS_UINT32           clock;        
    SS_UINT32           clock_type;     
    SS_UINT32           drop_times;        
    SS_BYTE             lock_sn[SLM_LOCK_SN_LENGTH];  
    SS_BYTE             user_info[128];     
    SS_BYTE             inner_info[128];    
} ST_LOCK_INFO;

typedef struct _ST_SESSION_INFO 
{
    SS_UINT32           size;            
    SS_UINT32           license_id;               
    union
    {
        SS_BYTE         sn[SLM_LOCK_SN_LENGTH];
        SS_BYTE         user_guid[SLM_GUID_LENGTH];
    };
    SS_UINT32           app_time_out;        
    SS_UINT32           app_process_id;      
    SS_UINT8            mac[SLM_MAC_SIZE];      
    char                session_id[SLM_MAX_SESSION_ID_SIZE]; 
    char                cpuinfo[SLM_MAX_CPU_INFO_SIZE];  
    char                bios[SLM_MAX_BIOS_INFO_SIZE];     
} ST_SESSION_INFO;

typedef struct _ST_SLM_LICENSE_INFO
{
    SS_UINT32   size;
    SS_UINT32   lic_ver;  
    SS_BYTE     flag[4];        
    SS_BYTE     guid[SLM_LOCK_SN_LENGTH];  
    SS_UINT32   lic_id;    
    SS_UINT32   start_time;     
    SS_UINT32   end_time;   
    SS_UINT32   span_time;    
    SS_UINT32   time_stamp;     
    SS_UINT16   serial;        
    SS_UINT16   concurrency;    
    SS_UINT32   count;         
    SS_UINT64   module_bit;    
    SS_UINT32   lock_time;      
    SS_UINT32   first_use_time; 
    SS_UINT32   curr_count;   
    SS_UINT32   offline_period; 
    SS_UINT32   bind_node;      
    SS_UINT32   max_bind_node;  
    SS_UINT32   raw_size;   
    SS_UINT32   rom_size;   
    SS_UINT32   pub_size;   
} ST_SLM_LICENSE_INFO;

typedef struct _ST_FILE_INFO 
{
    SS_BYTE     validate;                
    SS_BYTE     type;                    
    SS_UINT16   pri;              
    SS_UINT32   size;                  
    SS_UINT32   time;              
    SS_BYTE     name[16];                
} ST_FILE_INFO;

typedef struct _ST_FILE_INFO_LIST
{
    SS_UINT32       version;        
    SS_UINT32       count;
    ST_FILE_INFO    info[1];
} ST_FILE_INFO_LIST;

typedef struct _ST_DEV_INFO 
{
    SS_UINT16           desc_type;      
    SS_UINT16           firm_type;      
    SS_BYTE             developer_id[SLM_DEVELOPER_ID_SIZE];
    union 
    {
        struct 
        {
            SS_CHAR         cloud_server[114];
            SS_CHAR         user_token[48];
            SS_BYTE         user_guid[SLM_GUID_LENGTH];
        } cloud, smart_offline;  //  云锁/智能离线

        struct 
        {
            SS_BYTE         serial[SLM_LOCK_SN_LENGTH];
            SS_CHAR         ip[64];
            SS_UINT16       port;
            SS_CHAR         host_name[SLM_MAX_SERVER_NAME];
            //  reserved    
        } h5;  //  硬件锁

        struct 
        {
            SS_BYTE         user_guid[SLM_GUID_LENGTH];
            SS_CHAR         ip[64];
            SS_UINT16       port;
            //SS_BYTE         reserved[114 - 16 - 32];
            SS_CHAR         host_name[SLM_MAX_SERVER_NAME];
            // reserved for remote slock
            SS_CHAR         account_name[64];
        } slock;  //  软锁
    };

} ST_DEV_INFO;

typedef struct _ST_ENUM_DEVICE 
{
    ST_DEV_INFO     dev_info;
    ST_LOCK_INFO    lock_info;
} ST_ENUM_DEVICE;

typedef struct _ST_DEV_INFO_LIST
{
    SS_UINT32       version;        // 当前为1
    SS_UINT32       count;
    ST_ENUM_DEVICE  info[1];
} ST_DEV_INFO_LIST;

typedef struct _ST_LICENSE_IDS
{
    SS_UINT32       count;
    SS_UINT32       lic_ids[1];
} ST_LICENSE_IDS;

#ifdef __cplusplus
extern "C" {
#endif

SS_UINT32 SSAPI slm_init(IN ST_INIT_PARAM* pst_init);

SS_UINT32 SSAPI slm_find_license(
    IN  SS_UINT32           license_id,
    IN  INFO_FORMAT_TYPE    format,
    OUT char**              license_desc
    );


SS_UINT32 SSAPI slm_get_cloud_token(OUT SS_CHAR** access_token);

SS_UINT32 SSAPI slm_login(
    IN  const ST_LOGIN_PARAM*  license_param,
    IN  INFO_FORMAT_TYPE       param_format,
    OUT SLM_HANDLE_INDEX *     slm_handle,
    IN OUT void*               auth
    );

SS_UINT32 SSAPI slm_logout(SLM_HANDLE_INDEX slm_handle);

SS_UINT32 SSAPI slm_keep_alive(SLM_HANDLE_INDEX slm_handle);

SS_UINT32 SSAPI slm_encrypt(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_BYTE*            inbuffer,
    OUT SS_BYTE*            outbuffer,
    IN  SS_UINT32           len
    );

SS_UINT32 SSAPI slm_decrypt(
    IN  SLM_HANDLE_INDEX    slm_handle, 
    IN  SS_BYTE*            inbuffer, 
    OUT SS_BYTE*            outbuffer, 
    IN  SS_UINT32           len
    );

SS_UINT32 SSAPI slm_user_data_getsize(
    IN SLM_HANDLE_INDEX     slm_handle,
    IN LIC_USER_DATA_TYPE   type,
    OUT SS_UINT32*          pmem_size
    );

SS_UINT32 SSAPI slm_user_data_read(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  LIC_USER_DATA_TYPE  type,
    OUT SS_BYTE*            readbuf,
    IN  SS_UINT32           offset,
    IN  SS_UINT32           len
    );

SS_UINT32 SSAPI slm_user_data_write(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_BYTE*            writebuf,
    IN  SS_UINT32           offset,
    IN  SS_UINT32           len
    );

SS_UINT32 SSAPI slm_pub_data_getsize(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_UINT32           license_id,
    OUT SS_UINT32*          pmem_size
    );

SS_UINT32 SSAPI slm_pub_data_read(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_UINT32           license_id,
    OUT SS_BYTE*            readbuf,
    IN  SS_UINT32           offset,
    IN  SS_UINT32           len
    );

SS_UINT32 SSAPI slm_get_info(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  INFO_TYPE           type,
    IN  INFO_FORMAT_TYPE    format,
    OUT char**              result
    );

SS_UINT32 SSAPI slm_execute_static(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  const char*         exfname,
    IN  SS_BYTE*            inbuf,
    IN  SS_UINT32           insize,
    OUT SS_BYTE*            poutbuf,
    IN  SS_UINT32           outsize,
    OUT SS_UINT32*          pretsize
    );

SS_UINT32 SSAPI slm_execute_dynamic(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_BYTE*            exf_buffer,
    IN  SS_UINT32           exf_size,
    IN  SS_BYTE*            inbuf,
    IN  SS_UINT32           insize,
    OUT SS_BYTE*            poutbuf,
    IN  SS_UINT32           outsize,
    OUT SS_UINT32*          pretsize
    );

SS_UINT32 SSAPI slm_mem_alloc(
    IN  SLM_HANDLE_INDEX    slm_handle, 
    IN  SS_UINT32           size, 
    OUT SS_UINT32*          mem_id
    );

SS_UINT32 SSAPI slm_mem_free(
    IN  SLM_HANDLE_INDEX    slm_handle, 
    IN  SS_UINT32           mem_id
    );

SS_UINT32 SSAPI slm_mem_read(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_UINT32           mem_id,
    IN  SS_UINT32           offset,
    IN  SS_UINT32           len,
    IN  SS_BYTE*            readbuff,
    OUT SS_UINT32*          readlen
    );

SS_UINT32 SSAPI slm_mem_write(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_UINT32           mem_id,
    IN  SS_UINT32           offset,
    IN  SS_UINT32           len,
    IN  SS_BYTE*            writebuff,
    OUT SS_UINT32*          numberofbyteswritten
    );

SS_UINT32 SSAPI slm_is_debug(IN void *auth);

SS_UINT32 SSAPI slm_get_cert(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  CERT_TYPE           cert_type,
    OUT SS_BYTE*            cert,
    IN  SS_UINT32           cert_size,
    OUT SS_UINT32*          cert_len
    );

SS_UINT32 SSAPI slm_get_device_cert(
    IN  SLM_HANDLE_INDEX    slm_handle,
    OUT SS_BYTE*            device_cert,
    IN  SS_UINT32           buff_size,
    OUT SS_UINT32*          return_size
    );

SS_UINT32 SSAPI slm_sign_by_device(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_BYTE*            verify_data,
    IN  SS_UINT32           verify_data_size,
    OUT SS_BYTE*            signature,
    IN  SS_UINT32           signature_buf_size,
    OUT SS_UINT32*          signature_size
    );

SS_UINT32 SSAPI slm_adjust_time_request(
    IN  SLM_HANDLE_INDEX    slm_handle,
    OUT SS_BYTE             rand[SLM_FIXTIME_RAND_LENGTH],
    OUT SS_UINT32*          lock_time,
    IN OUT SS_UINT32*       pc_time
    );

SS_UINT32 SSAPI slm_led_control(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  ST_LED_CONTROL*     led_ctrl
    );

SS_UINT32 SSAPI slm_get_version(
    OUT SS_UINT32*      api_version, 
    OUT SS_UINT32*      ss_version
    );

void SSAPI slm_free(
    IN void*        buffer
    );

SS_UINT32 SSAPI slm_update(
    IN  char*       d2c_pkg, 
    OUT char**      error_msg
    );

SS_UINT32 SSAPI slm_update_ex(
    IN SS_BYTE*     lock_sn, 
    IN char*        d2c_pkg, 
    OUT char**      error_msg
    );

SS_UINT32 SSAPI slm_d2c_update_inside(
    IN char*        lock_sn,
    IN char*        inside_file
    );

SS_UINT32 SSAPI slm_enum_device(
    OUT char**  device_info
    );

SS_UINT32 SSAPI slm_enum_device_ex(
    IN  INFO_FORMAT_TYPE    format,
    OUT void                **device_info
    );

SS_UINT32 SSAPI slm_enum_license_id(
    IN const char   *device_info,
    OUT char        **license_ids
    );

SS_UINT32 SSAPI slm_enum_license_id_ex(
    IN  ST_DEV_INFO         *device_info,
    IN  INFO_FORMAT_TYPE    format,
    OUT void                **license_ids
    );

SS_UINT32 SSAPI slm_get_license_info(
    IN const char   *device_info,
    IN SS_UINT32    license_id,
    OUT char        **license_info
    );

SS_UINT32 SSAPI slm_get_license_info_ex(
    IN  ST_DEV_INFO          *device_info,
    IN  SS_UINT32           license_id,
    IN  INFO_FORMAT_TYPE    format,
    OUT void                **license_info
    );

SS_UINT32 SSAPI slm_check_module(IN SLM_HANDLE_INDEX slm_handle, IN SS_UINT32 module_id);

SS_UINT32 SSAPI slm_snippet_execute(
    IN  SLM_HANDLE_INDEX    slm_handle,
    IN  SS_BYTE*            snippet_code,
    IN  SS_UINT32           code_size,
    IN  SS_BYTE*            input, 
    IN  SS_UINT32           input_size, 
    OUT SS_BYTE*            output, 
    IN  SS_UINT32           outbuf_size, 
    OUT SS_UINT32*          output_size
    );

SS_UINT32 SSAPI slm_get_developer_id(OUT SS_BYTE developer_id[SLM_DEVELOPER_ID_SIZE]);

SS_UINT32 SSAPI slm_license_sign(
    IN  SLM_HANDLE_INDEX   slm_handle,
    IN  SS_BYTE           *sign_data,
    IN  SS_UINT32          sign_length,
    OUT SS_BYTE           *signature,
    IN  SS_UINT32          max_buf_size,
    OUT SS_UINT32         *signature_length
    );

SS_UINT32 SSAPI slm_license_verify(
    IN  SS_BYTE      *sign_data,
    IN  SS_UINT32       sign_length,
    IN  SS_BYTE      *signature,
    IN  SS_UINT32     signature_length,
    OUT char        **sign_info
    );

const SS_CHAR * SSAPI slm_error_format(
    IN SS_UINT32    error_code,
    IN SS_UINT32    language_id
    );

SS_UINT32 SSAPI slm_cleanup(void);

SS_UINT32 SSAPI slm_extensions_config(IN const char *config);

#ifdef __cplusplus
};
#endif //__cplusplus

#endif // #ifndef __SS_LM_RUMTIME_H__