m2mb_lwm2m.h

Go to the documentation of this file.

/* $version: 252203  */ 
/*===============================================================================================*/
/*         >>> Copyright (C) Telit Communications S.p.A. Italy All Rights Reserved. <<<          */
#ifndef  M2M_M2MB_LWM2M_API_H
#define  M2M_M2MB_LWM2M_API_H
 
 
/* Global declarations ==========================================================================*/
 
#define LWM2M_STRING_MAX_LENGTH            ( 20 )  /* max length allowed for the strings reporting client status, primitives etc. */
#define LWM2M_STAT_STRING_MAX_LENGTH       ( 10 )  /* max length allowed for the STAT string */
#define LWM2M_STS_ISBSTSRV_MAX_VALUE       ( 1 )   /* max value allowed for isBootstrapServer */
#define LWM2M_STS_EXTRA_CHARS_IN_URL       ( 3 )   /* extra chars for comma, isBstServer and string terminator, to be appended to URL */
#define LWM2M_STS_MIN_DATA_SIZE            ( 128 ) /* extra chars for comma, isBstServer and string terminator, to be appended to URL */
#define M2MB_LWM2M_ONE_BYTE                ( 1 )
#define M2MB_LWM2M_MAX_ENDPOINT_NAME_LEN   ( 64 )  /* max Endpoint Name length */
#define M2MB_LWM2M_DTLS_PSK_MAX_KEY_LEN    ( 64 )  /* max key length */
/* Global typedefs ==============================================================================*/
 
typedef HANDLE M2MB_LWM2M_HANDLE;
 
typedef enum
{
  M2MB_LWM2M_URI_0_FIELDS = 0, /* it should only be used on STS command, for selecting a server on the predefined table */
  M2MB_LWM2M_URI_1_FIELDS,     /* it should only be used on STS command */
  M2MB_LWM2M_URI_2_FIELDS,     /* it should only be used on STS command */
  M2MB_LWM2M_URI_3_FIELDS,     /* it should only be used on R/W/E commands */
  M2MB_LWM2M_URI_4_FIELDS,     /* it should only be used on R/W/E commands */
  M2MB_LWM2M_URI_MAX_NUM       /* it should only be used on STS command, for resetting the STS; any other values should be added before */
} M2MB_LWM2M_URI_LENGTH_E;
 
typedef enum
{
  M2MB_LWM2M_MODE_NO_ACK,
//  M2MB_LWM2M_MODE_TOUT_ACK,
  M2MB_LWM2M_MODE_ACK,
  M2MB_LWM2M_MODE_MAX_NUM
} M2MB_LWM2M_EN_MODE_E;
 
typedef enum
{
  M2MB_LWM2M_ACTION_ACK = 1,
  M2MB_LWM2M_ACTION_DEFER,
  M2MB_LWM2M_ACTION_MAX_NUM
} M2MB_LWM2M_ACK_ACTION_E;
 
typedef enum
{
  M2MB_LWM2MENA_CMD_TYPE_SET = 0,
  M2MB_LWM2MENA_CMD_TYPE_READ,
  M2MB_LWM2MENA_CMD_TYPE_MAX_NUM
} M2MB_LWM2MENA_CMD_TYPE_E;
 
typedef enum
{
  /* Responses */
  M2MB_LWM2M_ENABLE_RES = 0,
  M2MB_LWM2M_DISABLE_RES,
  M2MB_LWM2M_ACK_RES,
  M2MB_LWM2M_READ_RES,
  M2MB_LWM2M_WRITE_RES,
  M2MB_LWM2M_EXEC_RES,
  M2MB_LWM2M_SET_RES,
  M2MB_LWM2M_GET_RES,
  M2MB_LWM2M_GET_STAT_RES,
  M2MB_LWM2M_STS_RES,
  M2MB_LWM2M_MON_RES,
  M2MB_LWM2M_NEW_INST_RES,
  M2MB_LWM2M_NFYACK_STATUS_RES,
  M2MB_LWM2M_NFYACK_URI_RES,
  M2MB_LWM2M_NFYACK_LIST_RES,
  M2MB_LWM2M_GET_TYPE_RES,
  M2MB_LWM2M_CIPHER_CFG_RES,    
  M2MB_LWM2M_FOTA_CFG_RES,      
  M2MB_LWM2M_CIPHER_CFG_READ_RES, 
  M2MB_LWM2M_FOTA_CFG_READ_RES, 
  M2MB_LWM2M_FOTA_ACK_RES,      
  M2MB_LWM2M_FOTA_STATE_RES,    
  M2MB_LWM2M_INJKEYS_RES,
  M2MB_LWM2M_ODIS_RES,          
  M2MB_LWM2M_EXIST_RES,         
  M2MB_LWM2M_GET_LIST_NUM_RES,  
  M2MB_LWM2M_LIST_RES,          
  M2MB_LWM2M_CUST_RES,          
  M2MB_LWM2M_GET_REG_NUM_RES,   
  M2MB_LWM2M_REG_RES,           
  /* Indications */
  M2MB_LWM2M_UPD_REG_IND = 30,
  M2MB_LWM2M_SMS_PUSH_IND,
  M2MB_LWM2M_NOTIFY_IND,
  M2MB_LWM2M_NOTIFY_MON_IND,
 
  /* Special indications */
  M2MB_LWM2M_CONN_REQ_IND = 60,
  M2MB_LWM2M_SESSION_END_IND,
  M2MB_LWM2M_SESSION_INFO_IND,
  M2MB_LWM2M_SRV_INFO_IND,
  M2MB_LWM2M_MON_INFO_IND,
  M2MB_LWM2M_NFYACK_INFO_IND,
 
  /* Responses (continued from enum section 0-29)*/
  M2MB_LWM2M_OBJSET_RES = 90,   
  M2MB_LWM2M_OBJGET_RES,        
  M2MB_LWM2M_CFG_RES,           
  M2MB_LWM2M_EVENT_MAX_NUM
} M2MB_LWM2M_EVENT_E;
 
 
typedef enum
{
  M2MB_LWM2M_CONNREQ_CAUSE_BOOTSTRAP,
  M2MB_LWM2M_CONNREQ_CAUSE_REGISTRATION,
  M2MB_LWM2M_CONNREQ_CAUSE_REREG,
  M2MB_LWM2M_CONNREQ_CAUSE_UPDATE,
  M2MB_LWM2M_CONNREQ_CAUSE_SMS,
  M2MB_LWM2M_CONNREQ_CAUSE_NOTIFY,
  M2MB_LWM2M_CONNREQ_CAUSE_DEREGISTRATION,
  M2MB_LWM2M_CONNREQ_CAUSE_MAX_NUM
} M2MB_LWM2M_CONNREQ_CAUSE_E;
 
 
typedef enum
{
  /* General purpouse result codes */
  M2MB_LWM2M_RES_SUCCESS = 0,
  M2MB_LWM2M_RES_FAIL,
  M2MB_LWM2M_RES_FAIL_NO_ACTION,
  M2MB_LWM2M_RES_FAIL_UNSUPPORTED,
  M2MB_LWM2M_RES_FAIL_NOT_ALLOWED,
  M2MB_LWM2M_RES_FAIL_BAD_ARGS,
  M2MB_LWM2M_RES_FAIL_BAD_URI,
  M2MB_LWM2M_RES_FAIL_AGENT_UNAVAILABLE,      
  /* Network result codes */
  M2MB_LWM2M_RES_NETWORK_ERROR = 50,
  M2MB_LWM2M_RES_HOST_UNREACH,
  M2MB_LWM2M_RES_SOCKET_ERROR,
  M2MB_LWM2M_RES_DTLS_ERROR,
 
  /* LWM2M result codes */
  M2MB_LWM2M_RES_PROT_SUCCESS = 200,
  M2MB_LWM2M_RES_PROT_NOT_FOUND,
  M2MB_LWM2M_RES_PROT_NOT_ALLOWED,
  M2MB_LWM2M_RES_PROT_UNSUPPORTED,
  M2MB_LWM2M_RES_PROT_INTERNAL,
  M2MB_LWM2M_RES_PROT_UNKNOWN
} M2MB_LWM2M_RESULT_E;
 
typedef enum
{
  M2MB_LWM2M_IF_STATE_NONE,
 
  M2MB_LWM2M_IF_STATE_DISABLED,
  M2MB_LWM2M_IF_STATE_ACK_WAIT,
  M2MB_LWM2M_IF_STATE_ACTIVE,
  M2MB_LWM2M_IF_STATE_IDLE,
  M2MB_LWM2M_IF_STATE_DEREG_WAIT,
  M2MB_LWM2M_IF_STATE_DEREGISTERING,
 
  M2MB_LWM2M_IF_STATE_MAX
} M2MB_LWM2M_IF_STATE_E;
 
 
typedef enum
{
  M2MB_LWM2M_CL_STATE_DISABLED,
  /* alias added for clarity when referring to a server */
  M2MB_LWM2M_CL_STATE_DEREGISTERED = M2MB_LWM2M_CL_STATE_DISABLED,
  M2MB_LWM2M_CL_STATE_BOOTSTRAPPING,
  M2MB_LWM2M_CL_STATE_BOOTSTRAPPED,
  M2MB_LWM2M_CL_STATE_REGISTERING,
  M2MB_LWM2M_CL_STATE_REGISTERED,
  M2MB_LWM2M_CL_STATE_DEREGISTERING,
  M2MB_LWM2M_CL_STATE_SUSPENDED,
 
  M2MB_LWM2M_CL_STATE_MAX
} M2MB_LWM2M_CL_STATE_E;
 
typedef enum
{
  M2MB_LWM2M_SET_DATA_TYPE_INTEGER,
  M2MB_LWM2M_SET_DATA_TYPE_FLOAT,
  M2MB_LWM2M_SET_DATA_TYPE_STRING,
  M2MB_LWM2M_SET_DATA_TYPE_HEX_BINARY,
 
  M2MB_LWM2M_SET_DATA_TYPE_MAX
} M2MB_LWM2M_SET_DATA_TYPE_E;
 
typedef enum
{
  M2MB_LWM2M_INFO_FOTA_REBOOT,      
  M2MB_LWM2M_INFO_DEVICE_REBOOT,    
  M2MB_LWM2M_INFO_RESOURCE_EXECUTE, 
  M2MB_LWM2M_INFO_FORCE_EXIT,       
  M2MB_LWM2M_INFO_CLIENT_DISABLED,  
  M2MB_LWM2M_INFO_REG_FAILURE,      
  M2MB_LWM2M_INFO_ID_MAX
} M2MB_LWM2M_INFO_ID_E;
 
typedef enum
{
  M2MB_LWM2M_MON_DISABLE = 0,
  M2MB_LWM2M_MON_ENABLE,
  M2MB_LWM2M_MON_MAX_NUM
} M2MB_LWM2M_MON_ACTION_E;
 
typedef enum
{
  M2MB_LWM2M_MON_MODE_SET_CMD = 0,
  M2MB_LWM2M_MON_MODE_READ_CMD,
  M2MB_LWM2M_MON_MODE_MAX_NUM
} M2MB_LWM2M_MON_MODE_E;
 
typedef enum
{
  M2MB_LWM2M_CIPHER_MODE_DEFAULT  = 0, 
  M2MB_LWM2M_CIPHER_MODE_ECDH     = 1, 
  M2MB_LWM2M_CIPHER_MODE_MAX_NUM,      
  ENUM_TO_INT( M2MB_LWM2M_CIPHER_MODE_E )
} M2MB_LWM2M_CIPHER_MODE_E;
 
 
typedef enum
{
  M2MB_LWM2M_FOTA_MODE_DEFAULT  = 0, 
  M2MB_LWM2M_FOTA_MODE_ACK_DWL  = 1, 
  M2MB_LWM2M_FOTA_MODE_ACK_UPD  = 2, 
  M2MB_LWM2M_FOTA_MODE_ACK_ALL  = 3, 
  M2MB_LWM2M_FOTA_MODE_REJECT   = 4, 
  M2MB_LWM2M_FOTA_MODE_MAX_NUM,      
  ENUM_TO_INT( M2MB_LWM2M_FOTA_MODE_E )
} M2MB_LWM2M_FOTA_MODE_E;
 
typedef enum
{
  M2MB_LWM2M_FOTA_TOUT_ACTION_RESET_SM = 0, 
  M2MB_LWM2M_FOTA_TOUT_ACTION_ACK      = 1, 
  M2MB_LWM2M_FOTA_TOUT_ACTION_MAX_NUM,      
  ENUM_TO_INT( M2MB_LWM2M_FOTA_TOUT_ACTION_E )
} M2MB_LWM2M_FOTA_TOUT_ACTION_E;
 
typedef enum
{
  M2MB_LWM2M_FOTA_ACK_ALL = 1,  
  M2MB_LWM2M_FOTA_ACK_MAX_NUM   
} M2MB_LWM2M_FOTA_ACK_E;
 
typedef enum
{
  M2MB_LWM2M_NFY_STATE_MISSING = 0,   
  M2MB_LWM2M_NFY_STATE_ACK_RECEIVED,  
  M2MB_LWM2M_NFY_STATE_MAX_NUM        
} M2MB_LWM2M_NFY_STATE_E;
 
typedef enum
{
  M2MB_LWM2M_KEY_CREATE,                
  M2MB_LWM2M_KEY_DELETE_EP_NAME,        
  M2MB_LWM2M_KEY_DELETE_ID_AND_SECRET,  
  M2MB_LWM2M_KEY_DELETE_ALL,            
  M2MB_LWM2M_KEY_MAX_ACTION             
} M2MB_LWM2M_KEY_ACTION_E;
 
typedef enum
{
  ODIS_HOST_DEVICE_ID           = 0,    
  ODIS_HOST_DEVICE_MANUFACTURER = 1,    
  ODIS_HOST_DEVICE_MODEL        = 2,    
  ODIS_HOST_DEVICE_SW_VERSION   = 3,    
  ODIS_HOST_INSTANCE_ID         = 4,    
  ODIS_HOST_PARAM_MAX_NUMBER    = 5,    
  ENUM_TO_INT( ODIS_PARAMETERS_E )
} ODIS_PARAMETERS_E;
 
typedef enum
{
  M2MB_LWM2M_CUST_PARAM_ID_CARRIER = 0, 
  M2MB_LWM2M_CUST_PARAM_ID_DLT = 1,     
  M2MB_LWM2M_CUST_PARAM_ID_MAX,         
  ENUM_TO_INT( M2MB_LWM2M_CUST_PARAM_ID_E )
} M2MB_LWM2M_CUST_PARAM_ID_E;
 
typedef enum
{
  CUST_PARAMETERS_COMMAND_ID  = 0,  
  CUST_PARAMETERS_DATA        = 1,  
  CUST_PARAM_MAX_NUMBER,            
  ENUM_TO_INT( CUST_PARAMETERS_E )
} CUST_PARAMETERS_E;
 
typedef enum
{
  REG_PARAMETERS_AGENT_ID  = 0, 
  REG_PARAMETERS_SERVER_ID = 1, 
  REG_PARAMETERS_ACTION_ID = 2, 
  REG_PARAM_MAX_NUMBER,         
  ENUM_TO_INT( REG_PARAMETERS_E )
} REG_PARAMETERS_E;
 
typedef enum
{
  M2MB_LWM2M_REG_ACTION_FORCE_DEREG  = 0, 
  M2MB_LWM2M_REG_ACTION_FORCE_REG    = 1, 
  M2MB_LWM2M_REG_ACTION_UPDATE_REG   = 2, 
  M2MB_LWM2M_REG_ACTION_GET_SRV_INFO = 3, 
  M2MB_LWM2M_REG_ACTION_MAX_NUM,          
  ENUM_TO_INT( M2MB_LWM2M_REG_ACTION_E )
} M2MB_LWM2M_REG_ACTION_E;
 
typedef enum
{
  M2MB_LWM2M_REG_STATUS_DEREGISTERED = 0, 
  M2MB_LWM2M_REG_STATUS_SUSPENDED    = 1, 
  M2MB_LWM2M_REG_STATUS_REGISTERED   = 2, 
  M2MB_LWM2M_REG_STATUS_MAX_NUM,          
  ENUM_TO_INT( M2MB_LWM2M_REG_STATUS_E )
} M2MB_LWM2M_REG_STATUS_E;
 
typedef enum
{
  M2MB_LWM2M_REG_SUCCESS = 0,               
  M2MB_LWM2M_REG_ALREADY_REGISTERED = 1,    
  M2MB_LWM2M_REG_ALREADY_DEREGISTERED = 2,  
  M2MB_LWM2M_REG_SERVER_NOT_FOUND = 3,      
  M2MB_LWM2M_REG_CLIENT_DISABLED = 4,       
  M2MB_LWM2M_REG_MAX_NUM,                   
  ENUM_TO_INT( M2MB_LWM2M_REG_ERROR_CODE_E )
}
M2MB_LWM2M_REG_ERROR_CODE_E;
 
typedef enum
{
  M2MB_LWM2M_DATA_TYPE_INVALID = 0,     
  M2MB_LWM2M_DATA_TYPE_NONE,            
  M2MB_LWM2M_DATA_TYPE_STRING,          
  M2MB_LWM2M_DATA_TYPE_INTEGER,         
  M2MB_LWM2M_DATA_TYPE_FLOAT,           
  M2MB_LWM2M_DATA_TYPE_BOOLEAN,         
  M2MB_LWM2M_DATA_TYPE_OPAQUE,          
  M2MB_LWM2M_DATA_TYPE_TIME,            
  M2MB_LWM2M_DATA_TYPE_OBJECTLINK,      
  // arrays (for multiple resource instances) are their own type
  M2MB_LWM2M_DATA_TYPE_STRINGARRAY,     
  M2MB_LWM2M_DATA_TYPE_INTEGERARRAY,    
  M2MB_LWM2M_DATA_TYPE_FLOATARRAY,      
  M2MB_LWM2M_DATA_TYPE_BOOLEANARRAY,    
  M2MB_LWM2M_DATA_TYPE_OPAQUEARRAY,     
  M2MB_LWM2M_DATA_TYPE_TIMEARRAY,       
  M2MB_LWM2M_DATA_TYPE_OBJECTLINKARRAY, 
  // sentinel, do not remove
  M2MB_LWM2M_DATA_TYPE_LAST,            
  M2MB_LWM2M_DATA_TYPE_FIRSTARRAYTYPE = M2MB_LWM2M_DATA_TYPE_STRINGARRAY,    
  M2MB_LWM2M_DATA_TYPE_LASTARRAYTYPE = M2MB_LWM2M_DATA_TYPE_OBJECTLINKARRAY, 
} M2MB_LWM2M_DATA_TYPE_E;
 
typedef struct
{
  M2MB_LWM2M_EN_MODE_E     mode;
  UINT8                    apnclass;
  UINT8                    guardRequestEventSecs;
  UINT8                    guardReleaseEventSecs;
  M2MB_LWM2MENA_CMD_TYPE_E commandType;
} M2MB_LWM2M_ENABLE_REQ_T;
 
typedef struct
{
  M2MB_LWM2M_ACK_ACTION_E action;
//  UINT16                  defer_time;
} M2MB_LWM2M_ACK_REQ_T;
 
typedef struct
{
  UINT8  uriLen; /* 'M2MB_LWM2M_URI_3_FIELDS' for avoiding use of resourceInst, 'M2MB_LWM2M_URI_4_FIELDS' for including all the 4 Uri fields */
  UINT16 obj;
  UINT16 objInst;
  UINT16 resource;
  UINT16 resourceInst;
} M2MB_LWM2M_OBJ_URI_T;
 
typedef struct
{
  UINT16 obj;
  UINT16 objInst;
} M2MB_LWM2M_OBJ_LINK_T;
 
typedef struct
{
  UINT8   uriLen;           /* it represents the uri length; it should be 1 (in the case the only the URL has passed)
                             * or 2 (for URL and isBootstrapServer); if it is 1, the bootstrapRequest field is set to 0 */
  CHAR    *data;            /* server's URL */
  UINT32  dataLen;          /* server's URL length */
  UINT8   bootstrapRequest; /* 1 for bootstrap server, 0 for DM server */
  UINT32  serverTableId;    /* to be used in case the server is chosen by the predefined table, not used otherwise */
} M2MB_LWM2M_STS_URI_T;
 
typedef struct
{
  CHAR endpoint_name[M2MB_LWM2M_MAX_ENDPOINT_NAME_LEN+1];  
  CHAR identity[M2MB_LWM2M_DTLS_PSK_MAX_KEY_LEN+1];        
  CHAR secret_key[M2MB_LWM2M_DTLS_PSK_MAX_KEY_LEN+1];      
} M2MB_LWM2M_KEYS_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;                       
} M2MB_LWM2M_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_IF_STATE_E status;
  M2MB_LWM2M_EN_MODE_E  mode;
  UINT8                 apnclass;
  UINT8                 guardRequestEventSecs;
  UINT8                 guardReleaseEventSecs;
  CHAR                  clStatusString[LWM2M_STAT_STRING_MAX_LENGTH+1];
} M2MB_LWM2M_ENABLE_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_IF_STATE_E status;
} M2MB_LWM2M_DISABLE_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_IF_STATE_E status;
} M2MB_LWM2M_ACK_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E     result;
  M2MB_LWM2M_OBJ_URI_T    reqURI;
  void                    *data;
  SIZE_T                  len;
  M2MB_LWM2M_DATA_TYPE_E  resType;
} M2MB_LWM2M_READ_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E    result;
  M2MB_LWM2M_OBJ_URI_T   reqURI;
  void                   *data;
  UINT16                 len;
  M2MB_LWM2M_DATA_TYPE_E resType;
  UINT8                  bstrap;
} M2MB_LWM2M_WRITE_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_OBJ_URI_T  reqURI;
} M2MB_LWM2M_EXEC_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E  result;
  void                *data;
  UINT16               len;
  M2MB_LWM2M_OBJ_URI_T reqURI;
} M2MB_LWM2M_SET_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_OBJ_URI_T  reqURI;
  void                 *data;
  UINT16                len;
} M2MB_LWM2M_GET_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_IF_STATE_E status;
  M2MB_LWM2M_CL_STATE_E clStatus;
  UINT32                remainingSecs;
  UINT32                remainingMsecs;
} M2MB_LWM2M_GET_STAT_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
} M2MB_LWM2M_STS_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E     result;
  M2MB_LWM2M_OBJ_URI_T    reqURI;
  M2MB_LWM2M_DATA_TYPE_E  resType;
} M2MB_LWM2M_GET_TYPE_RES_T;
 
typedef struct
{
  M2MB_LWM2M_CONNREQ_CAUSE_E reason;
  UINT8                      apnclass;
  UINT32                     timeLeft;
} M2MB_LWM2M_CONN_REQ_IND_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_IF_STATE_E status;
 
} M2MB_LWM2M_SESSION_END_IND_T;
 
typedef struct
{
  M2MB_LWM2M_INFO_ID_E  info;                
  void                 *data;                
  UINT32                dataLen;             
  UINT16                agent;               
} M2MB_LWM2M_INFO_IND_T;
 
typedef struct
{
  M2MB_LWM2M_CL_STATE_E  info;               
  UINT16                 shServerId;         
  void                  *data;               
  UINT32                 dataLen;            
  UINT16                 agent;              
} M2MB_LWM2M_SRV_INFO_IND_T;
 
/* LWM2M Mon section */
typedef struct
{
  M2MB_LWM2M_MON_MODE_E   mode;
  M2MB_LWM2M_MON_ACTION_E action;
} M2MB_LWM2M_MON_REQ_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
  M2MB_LWM2M_MON_MODE_E mode;
  void                  *data;
  UINT16                dataLen;
} M2MB_LWM2M_MON_RES_T;
 
typedef struct
{
  M2MB_LWM2M_OBJ_URI_T   uri;
} M2MB_LWM2M_MON_INFO_IND_T;
 
/* LWM2M New Inst section */
typedef struct
{
  UINT16    agent;
} M2MB_LWM2M_NEW_INST_REQ_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;
} M2MB_LWM2M_NEW_INST_RES_T;
 
/* LWM2M Notify Ack section */
typedef struct
{
  M2MB_LWM2M_RESULT_E  result;               
  UINT16               agent;                
  BOOLEAN              enabled;              
} M2MB_LWM2M_NFYACK_STATUS_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E result;                
  UINT16              agent;                 
} M2MB_LWM2M_NFYACK_URI_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;              
  UINT16                agent;               
  M2MB_LWM2M_OBJ_URI_T *uriList;             
  UINT8                 listElementsNumber;  
} M2MB_LWM2M_NFYACK_LIST_RES_T;
 
typedef struct
{
  M2MB_LWM2M_OBJ_URI_T    uri;                
  UINT16                  agent;              
  UINT16                  shServerId;         
  M2MB_LWM2M_NFY_STATE_E  nfyState;           
} M2MB_LWM2M_NFYACK_INFO_IND_T;
 
/* LWM2M CIPHER CFG */
typedef struct
{
  M2MB_LWM2M_CIPHER_MODE_E         mode;    
} M2MB_LWM2M_CIPHER_CFG_REQ_T;
 
 
/* LWM2M FOTA CFG */
typedef struct
{
  M2MB_LWM2M_FOTA_MODE_E         mode;    
  M2MB_LWM2M_FOTA_TOUT_ACTION_E  toutAct; 
} M2MB_LWM2M_FOTA_CFG_REQ_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E           result;  
  M2MB_LWM2M_CIPHER_MODE_E        mode;  
} M2MB_LWM2M_CIPHER_CFG_RES_T;
 
 
typedef struct
{
  M2MB_LWM2M_RESULT_E           result;  
  M2MB_LWM2M_FOTA_MODE_E        mode;    
  M2MB_LWM2M_FOTA_TOUT_ACTION_E toutAct; 
} M2MB_LWM2M_FOTA_CFG_RES_T;
 
typedef struct
{
  UINT16                   agent;        
  M2MB_LWM2M_CIPHER_MODE_E cipherCfg;    
} M2MB_LWM2M_CIPHER_CFG_ITEM_T;
 
 
 
typedef struct
{
  UINT16                 agent;          
  M2MB_LWM2M_FOTA_MODE_E fotaCfg;        
  M2MB_LWM2M_FOTA_TOUT_ACTION_E toutAct; 
} M2MB_LWM2M_FOTA_CFG_ITEM_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E           result;           
  M2MB_LWM2M_CIPHER_CFG_ITEM_T  *cipherCfgData;   
  UINT16                        elementsNumber;   
} M2MB_LWM2M_CIPHER_CFG_READ_RES_T;
 
 
 
typedef struct
{
  M2MB_LWM2M_RESULT_E         result;           
  M2MB_LWM2M_FOTA_CFG_ITEM_T  *fotaCfgData;     
  UINT16                      elementsNumber;   
} M2MB_LWM2M_FOTA_CFG_READ_RES_T;
 
/* LWM2M FOTA ACK */
typedef struct
{
  M2MB_LWM2M_FOTA_ACK_E action; 
} M2MB_LWM2M_FOTA_ACK_REQ_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result; 
} M2MB_LWM2M_FOTA_ACK_RES_T;
 
/* LWM2M FOTA STATUS */
typedef struct M2MB_LWM2M_FOTA_STATUS_REQ_TAG
{
  UINT16                 agent;   
} M2MB_LWM2M_FOTA_STATUS_REQ_T;
 
typedef enum
{
  LWM2M_FOTA_INTERNAL_STATUS_IDLE,          
  LWM2M_FOTA_INTERNAL_STATUS_RESERVED_1,    
  LWM2M_FOTA_INTERNAL_STATUS_WAIT_DWL_ACK,  
  LWM2M_FOTA_INTERNAL_STATUS_DOWNLOADING,   
  LWM2M_FOTA_INTERNAL_STATUS_DOWNLOADED,    
  LWM2M_FOTA_INTERNAL_STATUS_RESERVED_2,    
  LWM2M_FOTA_INTERNAL_STATUS_WAIT_UPD_ACK,  
  LWM2M_FOTA_INTERNAL_STATUS_UPDATING,      
  LWM2M_FOTA_INTERNAL_STATUS_REJECT,        
  LWM2M_FOTA_INTERNAL_STATUS_FAILED,        
  LWM2M_FOTA_INTERNAL_STATUS_MAX_NUMBER,    
  ENUM_TO_INT( LWM2M_FOTA_INTERNAL_STATUS_E )
} LWM2M_FOTA_INTERNAL_STATUS_E;
 
typedef enum
{
  LWM2M_FW_OBJ_STATE_IDLE,        
  LWM2M_FW_OBJ_STATE_DOWNLOADING, 
  LWM2M_FW_OBJ_STATE_DOWNLOADED,  
  LWM2M_FW_OBJ_STATE_UPDATING,    
  LWM2M_FW_OBJ_STATE_MAX_NUMBER,  
  ENUM_TO_INT( LWM2M_FW_OBJ_STATE_E )
} LWM2M_FW_OBJ_STATE_E;
 
typedef struct M2MB_LWM2M_FOTA_STATE_TAG
{
  LWM2M_FW_OBJ_STATE_E          fwUpdObjectStatus;  
  LWM2M_FOTA_INTERNAL_STATUS_E  firmwareStatus;     
  UINT64                        remainingTime;      
} M2MB_LWM2M_FOTA_STATE_T;
 
typedef struct M2MB_LWM2M_FOTA_STATE_RES_TAG
{
  M2MB_LWM2M_RESULT_E       result;          
  M2MB_LWM2M_FOTA_STATE_T  *fotaStateData;   
} M2MB_LWM2M_FOTA_STATE_RES_T;
 
typedef struct
{
  CHAR *pHostDevUniqueID;     
  CHAR *pHostDevManufacturer; 
  CHAR *pHostDevModel;        
  CHAR *pHostDevSwVersion;    
  UINT8 odisInstance;         
}M2MB_LWM2M_ODIS_DATA_T;
 
typedef struct M2MB_LWM2M_GET_LIST_NUM_RES_TAG
{
  M2MB_LWM2M_RESULT_E   result;      
  UINT16                listEntries; 
} M2MB_LWM2M_GET_LIST_NUM_RES_T;
 
typedef struct M2MB_LWM2M_LIST_ELEMENT_RES_TAG
{
  UINT16                objectID;     
  UINT16                objectInstID; 
} M2MB_LWM2M_LIST_ELEMENT_RES_T;
 
typedef struct M2MB_LWM2M_LIST_RES_TAG
{
  M2MB_LWM2M_RESULT_E           result;         
  M2MB_LWM2M_LIST_ELEMENT_RES_T *list;          
  UINT16                        listSize;       
  UINT16                        entriesWritten; 
  BOOLEAN                       isTruncated;    
} M2MB_LWM2M_LIST_RES_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result; 
} M2MB_LWM2M_ODIS_RES_T;
 
typedef void ( *m2mb_lwm2m_ind_callback )( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_EVENT_E event, UINT16 resp_size, void *resp_struct, void *userdata );
 
/* LWM2M EXIST */
typedef struct
{
  M2MB_LWM2M_RESULT_E   result;     
  M2MB_LWM2M_OBJ_URI_T  reqURI;     
  UINT16                reqAgent;   
  BOOLEAN               isExistent; 
} M2MB_LWM2M_EXIST_RES_T;
 
typedef struct
{
  void                   *buffer;   
  M2MB_LWM2M_DATA_TYPE_E dataType;  
  SIZE_T                 dataSize;  
} M2MB_LWM2M_CUST_DATA_T;
 
typedef struct
{
  M2MB_LWM2M_CUST_PARAM_ID_E  paramId;  
  M2MB_LWM2M_CUST_DATA_T      data;     
} M2MB_LWM2M_CUST_PARAM_T;
 
typedef struct
{
  M2MB_LWM2M_RESULT_E   result; 
} M2MB_LWM2M_CUST_RES_T;
 
typedef struct M2MB_LWM2M_GET_REG_NUM_RES_TAG
{
  M2MB_LWM2M_RESULT_E   result;     
  UINT16                regEntries; 
} M2MB_LWM2M_GET_REG_NUM_RES_T;
 
typedef struct M2MB_LWM2M_REG_ELEMENT_RES_TAG
{
  UINT16    sshid;                
  M2MB_LWM2M_REG_STATUS_E status; 
  UINT64    lastReg;              
  UINT64    nextReg;              
  UINT64    lastActivity;         
} M2MB_LWM2M_REG_ELEMENT_RES_T;
 
typedef struct M2MB_LWM2M_REG_PARAM_TAG
{
  UINT16                  agentId;   
  UINT16                  *serverId; 
  M2MB_LWM2M_REG_ACTION_E actionId;  
} M2MB_LWM2M_REG_PARAM_T;
 
typedef struct M2MB_LWM2M_REG_RES_TAG
{
  M2MB_LWM2M_RESULT_E          result;    
  M2MB_LWM2M_REG_ERROR_CODE_E  error;     
  M2MB_LWM2M_REG_ELEMENT_RES_T *list;     
  UINT16                       listSize;  
} M2MB_LWM2M_REG_RES_T;
 
typedef enum
{
  M2MB_LWM2M_CFG_ACTIONID_SET    = 0, 
  M2MB_LWM2M_CFG_ACTIONID_GET    = 1, 
  M2MB_LWM2M_CFG_ACTIONID_MAX_NUM,    
  ENUM_TO_INT( M2MB_LWM2M_CFG_ACTIONID_E )
} M2MB_LWM2M_CFG_ACTIONID_E;
 
typedef enum
{
  M2MB_LWM2M_CFG_PARAMID_STOUT        = 0,   
  M2MB_LWM2M_CFG_PARAMID_IPV4_ONLY    = 1,   
  M2MB_LWM2M_CFG_PARAMID_COAP_ACK     = 2,   
  M2MB_LWM2M_CFG_PARAMID_COAP_RETRANS = 3,   
  M2MB_LWM2M_CFG_PARAMID_MAX_NUM,            
  ENUM_TO_INT( M2MB_LWM2M_CFG_PARAMID_E )
} M2MB_LWM2M_CFG_PARAMID_E;
 
typedef struct M2MB_LWM2M_CFG_PARAM_TAG
{
  UINT16                      agentId;   
  M2MB_LWM2M_CFG_PARAMID_E    paramId;   
  M2MB_LWM2M_CFG_ACTIONID_E   actionId;  
  UINT32                      value;     
} M2MB_LWM2M_CFG_PARAM_T;
 
typedef struct M2MB_LWM2M_CFG_RES_TAG
{
  M2MB_LWM2M_RESULT_E         result;   
  UINT16                      agentId;  
  M2MB_LWM2M_CFG_PARAMID_E    paramId;  
  M2MB_LWM2M_CFG_ACTIONID_E   actionId; 
  UINT32                      value;    
} M2MB_LWM2M_CFG_RES_T;
 
typedef struct M2MB_LWM2M_OBJSET_PARAM_TAG
{
  UINT16 objectId;            
  UINT16 objectInstanceId;    
  CHAR*  dataString;          
  UINT32 dataStringSize;      
} M2MB_LWM2M_OBJSET_PARAM_T;
 
typedef struct M2MB_LWM2M_OBJSET_RES_TAG
{
  M2MB_LWM2M_RESULT_E result;    
} M2MB_LWM2M_OBJSET_RES_T;
 
typedef struct M2MB_LWM2M_OBJGET_PARAM_TAG
{
  UINT16 agentId;              
  M2MB_LWM2M_OBJ_URI_T   uri;  
} M2MB_LWM2M_OBJGET_PARAM_T;
 
typedef struct M2MB_LWM2M_OBJGET_RES_TAG
{
  M2MB_LWM2M_RESULT_E result;    
  CHAR*  dataString;             
  UINT32 dataStringSize;         
} M2MB_LWM2M_OBJGET_RES_T;
 
 
/* Global functions =============================================================================*/
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_init( M2MB_LWM2M_HANDLE *h, m2mb_lwm2m_ind_callback cb, void *cb_user_param );
 
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_deinit( M2MB_LWM2M_HANDLE h );
 
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_enable( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_ENABLE_REQ_T *en_params );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_disable( M2MB_LWM2M_HANDLE h );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_ack( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_ACK_REQ_T *ack );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_read( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri, void *outbuf, UINT16 outbuflen );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_write( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri, void *inbuf, UINT16 inbuflen );
 
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_exec( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri );
 
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_set( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri, void *inbuf, UINT16 inbuflen );
 
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_get( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri, void *outbuf, UINT16 outbuflen );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_get_stat( M2MB_LWM2M_HANDLE h );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_sts( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_STS_URI_T *reqStsStructure );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_mon( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri, M2MB_LWM2M_MON_REQ_T *mon_params );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_newinst( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri, M2MB_LWM2M_NEW_INST_REQ_T *new_inst_params );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_nfy_ack_status( M2MB_LWM2M_HANDLE h, BOOLEAN set, BOOLEAN enable );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_nfy_ack_uri( M2MB_LWM2M_HANDLE h, BOOLEAN add, M2MB_LWM2M_OBJ_URI_T *uri );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_nfy_ack_list( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uriList, UINT8 listElementsNumber );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_agent_config( M2MB_LWM2M_HANDLE h, UINT16 agentID );
 
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_get_resource_type( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri, UINT16 *resType );
 
M2MB_RESULT_E m2mb_lwm2m_cipher_cfg( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_CIPHER_CFG_REQ_T *cfg_params );
 
M2MB_RESULT_E m2mb_lwm2m_cipher_cfg_read( M2MB_LWM2M_HANDLE h,
                                        M2MB_LWM2M_CIPHER_CFG_ITEM_T *cipherCfgData,
                                        UINT8 maxItemsNumber );
 
M2MB_RESULT_E m2mb_lwm2m_fota_cfg( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_FOTA_CFG_REQ_T *cfg_params );
 
M2MB_RESULT_E m2mb_lwm2m_fota_cfg_read( M2MB_LWM2M_HANDLE h,
                                        M2MB_LWM2M_FOTA_CFG_ITEM_T *fotaCfgData,
                                        UINT8 maxItemsNumber );
 
M2MB_RESULT_E m2mb_lwm2m_fota_ack( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_FOTA_ACK_REQ_T *ack_params );
 
M2MB_RESULT_E m2mb_lwm2m_fota_status( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_FOTA_STATE_T *fotaStateData );
 
M2MB_RESULT_E m2mb_lwm2m_injkeys( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_KEY_ACTION_E action, M2MB_LWM2M_KEYS_T *keys );
 
M2MB_RESULT_E m2mb_lwm2m_odis_reset( M2MB_LWM2M_HANDLE h );
 
M2MB_RESULT_E m2mb_lwm2m_odis_config( M2MB_LWM2M_HANDLE h, ODIS_PARAMETERS_E odis_item, CHAR *odis_data );
 
M2MB_RESULT_E m2mb_lwm2m_odis( M2MB_LWM2M_HANDLE h );
 
M2MB_RESULT_E m2mb_lwm2m_odis_set( M2MB_LWM2M_HANDLE h, UINT8 odis_instance );
 
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_exist( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_OBJ_URI_T *uri );
 
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_get_list_entries( M2MB_LWM2M_HANDLE h );
 
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_list( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_LIST_ELEMENT_RES_T *listPointer, UINT16 listSize );
 
M2MB_RESULT_E m2mb_lwm2m_cust( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_CUST_PARAM_T *custReq );
 
/*-----------------------------------------------------------------------------------------------*/
 
M2MB_RESULT_E m2mb_lwm2m_cfg( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_CFG_PARAM_T *cfgReq );
 
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_get_reg_entries( M2MB_LWM2M_HANDLE h );
 
/*-----------------------------------------------------------------------------------------------*/
M2MB_RESULT_E m2mb_lwm2m_reg( M2MB_LWM2M_HANDLE h, M2MB_LWM2M_REG_PARAM_T *regReq,
                              M2MB_LWM2M_REG_ELEMENT_RES_T *listPointer, UINT16 listSize );
 
M2MB_RESULT_E m2mb_lwm2m_objset( M2MB_LWM2M_HANDLE h, const M2MB_LWM2M_OBJSET_PARAM_T* objSetReq );
 
M2MB_RESULT_E m2mb_lwm2m_objget( M2MB_LWM2M_HANDLE h, const M2MB_LWM2M_OBJGET_PARAM_T* objGetReq,
                                 CHAR* objGetRespString, UINT16 objGetRespSize );
#endif