lwm2m_context_t * lwm2m_init(char * endpointName,
uint16_t numObject,
lwm2m_object_t * objectList[],
lwm2m_buffer_send_callback_t bufferSendCallback,
void * bufferSendUserData)
{
lwm2m_context_t * contextP;
if (NULL == bufferSendCallback)
return NULL;
#ifdef LWM2M_CLIENT_MODE
if (numObject != 0)
{
int i;
for (i = 0 ; i < numObject ; i++)
{
if (objectList[i]->objID <= LWM2M_ACL_OBJECT_ID)
{
// Use of a reserved object ID
return NULL;
}
}
}
#endif
contextP = (lwm2m_context_t *)lwm2m_malloc(sizeof(lwm2m_context_t));
if (NULL != contextP)
{
memset(contextP, 0, sizeof(lwm2m_context_t));
contextP->bufferSendCallback = bufferSendCallback;
contextP->bufferSendUserData = bufferSendUserData;
#ifdef LWM2M_CLIENT_MODE
contextP->endpointName = strdup(endpointName);
if (contextP->endpointName == NULL)
{
lwm2m_free(contextP);
return NULL;
}
if (numObject != 0)
{
contextP->objectList = (lwm2m_object_t **)lwm2m_malloc(numObject * sizeof(lwm2m_object_t *));
if (NULL != contextP->objectList)
{
memcpy(contextP->objectList, objectList, numObject * sizeof(lwm2m_object_t *));
contextP->numObject = numObject;
}
else
{
lwm2m_free(contextP->endpointName);
lwm2m_free(contextP);
return NULL;
}
}
#endif
}
return contextP;
}
void copy_security_object(lwm2m_object_t * objectDest, lwm2m_object_t * objectSrc)
{
memcpy(objectDest, objectSrc, sizeof(lwm2m_object_t));
objectDest->instanceList = NULL;
objectDest->userData = NULL;
security_instance_t * instanceSrc = (security_instance_t *)objectSrc->instanceList;
security_instance_t * previousInstanceDest = NULL;
while (instanceSrc != NULL)
{
security_instance_t * instanceDest = (security_instance_t *)lwm2m_malloc(sizeof(security_instance_t));
if (NULL == instanceDest)
{
return;
}
memcpy(instanceDest, instanceSrc, sizeof(security_instance_t));
instanceDest->uri = (char*)lwm2m_malloc(strlen(instanceSrc->uri) + 1);
strcpy(instanceDest->uri, instanceSrc->uri);
instanceSrc = (security_instance_t *)instanceSrc->next;
if (previousInstanceDest == NULL)
{
objectDest->instanceList = (lwm2m_list_t *)instanceDest;
}
else
{
previousInstanceDest->next = instanceDest;
}
previousInstanceDest = instanceDest;
}
}
void copy_security_object(lwm2m_object_t * objectDest, lwm2m_object_t * objectSrc)
{
memcpy(objectDest, objectSrc, sizeof(lwm2m_object_t));
objectDest->instanceList = NULL;
objectDest->userData = NULL;
security_instance_t * instanceSrc = (security_instance_t *)objectSrc->instanceList;
security_instance_t * previousInstanceDest = NULL;
while (instanceSrc != NULL)
{
security_instance_t * instanceDest = (security_instance_t *)lwm2m_malloc(sizeof(security_instance_t));
if (NULL == instanceDest)
{
return;
}
memcpy(instanceDest, instanceSrc, sizeof(security_instance_t));
instanceDest->uri = (char*)lwm2m_malloc(strlen(instanceSrc->uri) + 1);
strcpy(instanceDest->uri, instanceSrc->uri);
if (instanceSrc->securityMode == LWM2M_SECURITY_MODE_PRE_SHARED_KEY)
{
instanceDest->publicIdentity = lwm2m_strdup(instanceSrc->publicIdentity);
instanceDest->secretKey = lwm2m_strdup(instanceSrc->secretKey);
}
instanceSrc = (security_instance_t *)instanceSrc->next;
if (previousInstanceDest == NULL)
{
objectDest->instanceList = (lwm2m_list_t *)instanceDest;
}
else
{
previousInstanceDest->next = instanceDest;
}
previousInstanceDest = instanceDest;
}
}
lwm2m_transaction_t * transaction_new(coap_method_t method,
lwm2m_uri_t * uriP,
uint16_t mID,
lwm2m_endpoint_type_t peerType,
void * peerP)
{
lwm2m_transaction_t * transacP;
int result;
transacP = (lwm2m_transaction_t *)lwm2m_malloc(sizeof(lwm2m_transaction_t));
if (transacP == NULL) return NULL;
memset(transacP, 0, sizeof(lwm2m_transaction_t));
transacP->message = lwm2m_malloc(sizeof(coap_packet_t));
if (transacP->message == NULL) goto error;
coap_init_message(transacP->message, COAP_TYPE_CON, method, mID);
transacP->mID = mID;
transacP->peerType = peerType;
transacP->peerP = peerP;
if (uriP != NULL)
{
result = snprintf(transacP->objStringID, LWM2M_STRING_ID_MAX_LEN, "%hu", uriP->objectId);
if (result < 0 || result > LWM2M_STRING_ID_MAX_LEN) goto error;
coap_set_header_uri_path_segment(transacP->message, transacP->objStringID);
if (LWM2M_URI_IS_SET_INSTANCE(uriP))
{
result = snprintf(transacP->instanceStringID, LWM2M_STRING_ID_MAX_LEN, "%hu", uriP->instanceId);
if (result < 0 || result > LWM2M_STRING_ID_MAX_LEN) goto error;
coap_set_header_uri_path_segment(transacP->message, transacP->instanceStringID);
}
else
{
if (LWM2M_URI_IS_SET_RESOURCE(uriP))
{
coap_set_header_uri_path_segment(transacP->message, NULL);
}
}
if (LWM2M_URI_IS_SET_RESOURCE(uriP))
{
result = snprintf(transacP->resourceStringID, LWM2M_STRING_ID_MAX_LEN, "%hu", uriP->resourceId);
if (result < 0 || result > LWM2M_STRING_ID_MAX_LEN) goto error;
coap_set_header_uri_path_segment(transacP->message, transacP->resourceStringID);
}
}
return transacP;
error:
lwm2m_free(transacP);
return NULL;
}
lwm2m_object_t * get_object_firmware(void)
{
/*
* The get_object_firmware function create the object itself and return a pointer to the structure that represent it.
*/
lwm2m_object_t * obj;
obj = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != obj) {
memset(obj, 0, sizeof(lwm2m_object_t));
/*
* It assigns its unique ID
* The 5 is the standard ID for the optional object "Object firmware".
*/
obj->objID = LWM2M_FIRMWARE_UPDATE_OBJECT_ID;
/*
* and its unique instance
*
*/
obj->instanceList = (lwm2m_list_t *)lwm2m_malloc(sizeof(lwm2m_list_t));
if (NULL != obj->instanceList) {
memset(obj->instanceList, 0, sizeof(lwm2m_list_t));
} else {
lwm2m_free(obj);
return NULL;
}
/*
* And the private function that will access the object.
* Those function will be called when a read/write/execute query is made by the server. In fact the library don't need to
* know the resources of the object, only the server does.
*/
obj->readFunc = prv_firmware_read;
obj->writeFunc = prv_firmware_write;
obj->executeFunc = prv_firmware_execute;
obj->closeFunc = prv_firmware_close;
obj->userData = lwm2m_malloc(sizeof(firmware_data_t));
/*
* Also some user data can be stored in the object with a private structure containing the needed variables
*/
if (NULL != obj->userData) {
((firmware_data_t*)obj->userData)->state = 1;
((firmware_data_t*)obj->userData)->supported = 0;
((firmware_data_t*)obj->userData)->result = 0;
} else {
lwm2m_free(obj);
obj = NULL;
}
}
return obj;
}
lwm2m_object_t * get_object_accelerometer() {
/*
* The get_object_accelerometer function create the object itself and return a pointer to the structure that represent it.
*/
lwm2m_object_t * accelerometerObj;
accelerometerObj = (lwm2m_object_t *) lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != accelerometerObj) {
memset(accelerometerObj, 0, sizeof(lwm2m_object_t));
/*
* It assigns his unique ID
* The 3313 is the standard ID for the mandatory object "IPSO Accelerometer".
*/
accelerometerObj->objID = LWM2M_ACCELEROMETER_OBJECT_ID;
/*
* there is only one instance of accelerometer on the Application Board for mbed NXP LPC1768.
*
*/
accelerometerObj->instanceList = (lwm2m_list_t *) lwm2m_malloc(sizeof(lwm2m_list_t));
if (NULL != accelerometerObj->instanceList) {
memset(accelerometerObj->instanceList, 0, sizeof(lwm2m_list_t));
} else {
lwm2m_free(accelerometerObj);
return NULL;
}
/*
* And the private function that will access the object.
* Those function will be called when a read/write/execute query is made by the server. In fact the library don't need to
* know the resources of the object, only the server does.
*/
accelerometerObj->readFunc = prv_accelerometer_read;
accelerometerObj->writeFunc = NULL;
accelerometerObj->executeFunc = NULL;
accelerometerObj->closeFunc = prv_accelerometer_close;
accelerometerObj->userData = lwm2m_malloc(sizeof(accelometer_data_t));
/*
* Also some user data can be stored in the object with a private structure containing the needed variables
*/
if (NULL != accelerometerObj->userData) {
((accelometer_data_t*) accelerometerObj->userData)->previous_x = -1;
((accelometer_data_t*) accelerometerObj->userData)->previous_y = -1;
((accelometer_data_t*) accelerometerObj->userData)->previous_z = -1;
} else {
lwm2m_free(accelerometerObj);
accelerometerObj = NULL;
}
}
return accelerometerObj;
}
lwm2m_object_t * get_object_conn_s(void)
{
/*
* The get_object_conn_s() function create the object itself and return
* a pointer to the structure that represent it.
*/
lwm2m_object_t * connObj;
connObj = (lwm2m_object_t *) lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != connObj)
{
memset(connObj, 0, sizeof(lwm2m_object_t));
/*
* It assign his unique ID
* The 7 is the standard ID for the optional object "Connectivity Statistics".
*/
connObj->objID = LWM2M_CONN_STATS_OBJECT_ID;
connObj->instanceList = lwm2m_malloc(sizeof(lwm2m_list_t));
if (NULL != connObj->instanceList)
{
memset(connObj->instanceList, 0, sizeof(lwm2m_list_t));
}
else {
lwm2m_free(connObj);
return NULL;
}
/*
* And the private function that will access the object.
* Those function will be called when a read/execute/close
* query is made by the server or core. In fact the library don't need
* to know the resources of the object, only the server does.
*/
connObj->readFunc = prv_read;
connObj->executeFunc = prv_exec;
connObj->userData = lwm2m_malloc(sizeof(conn_s_data_t));
/*
* Also some user data can be stored in the object with a private
* structure containing the needed variables.
*/
if (NULL != connObj->userData)
{
prv_resetCounter(connObj, false);
}
else
{
lwm2m_free(connObj);
connObj = NULL;
}
}
return connObj;
}
/**
* This function creates the LWM2M Location.
* @return gives back allocated LWM2M data object structure pointer. On error,
* NULL value is returned.
*/
lwm2m_object_t * get_object_location(void)
{
//-------------------------------------------------------------------- JH --
lwm2m_object_t * locationObj;
locationObj = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != locationObj)
{
memset(locationObj, 0, sizeof(lwm2m_object_t));
// It assigns its unique ID
// The 6 is the standard ID for the optional object "Location".
locationObj->objID = LWM2M_LOCATION_OBJECT_ID;
// and its unique instance
locationObj->instanceList = (lwm2m_list_t *)lwm2m_malloc(sizeof(lwm2m_list_t));
if (NULL != locationObj->instanceList)
{
memset(locationObj->instanceList, 0, sizeof(lwm2m_list_t));
}
else
{
lwm2m_free(locationObj);
return NULL;
}
// And the private function that will access the object.
// Those function will be called when a read query is made by the server.
// In fact the library don't need to know the resources of the object, only the server does.
//
locationObj->readFunc = prv_location_read;
locationObj->closeFunc = prv_location_close;
locationObj->userData = lwm2m_malloc(sizeof(location_data_t));
// initialize private data structure containing the needed variables
if (NULL != locationObj->userData)
{
location_data_t* data = (location_data_t*)locationObj->userData;
strcpy (data->latitude, "27.986065"); // Mount Everest :)
strcpy (data->longitude, "86.922623");
strcpy (data->altitude, "8495.0000");
strcpy (data->uncertainty, "0.01");
location_setVelocity(locationObj, 0, 0, 255); // 255: speedUncertainty not supported!
data->timestamp = time(NULL);
}
else
{
lwm2m_free(locationObj);
locationObj = NULL;
}
}
return locationObj;
}
lwm2m_object_t * get_server_object(int serverId,
const char* binding,
int lifetime,
bool storing)
{
lwm2m_object_t * serverObj;
serverObj = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != serverObj)
{
server_instance_t * serverInstance;
memset(serverObj, 0, sizeof(lwm2m_object_t));
serverObj->objID = 1;
// Manually create an hardcoded server
serverInstance = (server_instance_t *)lwm2m_malloc(sizeof(server_instance_t));
if (NULL == serverInstance)
{
lwm2m_free(serverObj);
return NULL;
}
memset(serverInstance, 0, sizeof(server_instance_t));
serverInstance->instanceId = 0;
serverInstance->shortServerId = serverId;
serverInstance->lifetime = lifetime;
serverInstance->storing = storing;
memcpy (serverInstance->binding, binding, strlen(binding)+1);
#ifndef LWM2M_VERSION_1_0
serverInstance->registrationPriorityOrder = -1;
serverInstance->initialRegistrationDelayTimer = -1;
serverInstance->registrationFailureBlock = -1;
serverInstance->bootstrapOnRegistrationFailure = -1;
serverInstance->communicationRetryCount = -1;
serverInstance->communicationRetryTimer = -1;
serverInstance->communicationSequenceDelayTimer = -1;
serverInstance->communicationSequenceRetryCount = -1;
#endif
serverObj->instanceList = LWM2M_LIST_ADD(serverObj->instanceList, serverInstance);
serverObj->readFunc = prv_server_read;
serverObj->discoverFunc = prv_server_discover;
serverObj->writeFunc = prv_server_write;
serverObj->createFunc = prv_server_create;
serverObj->deleteFunc = prv_server_delete;
serverObj->executeFunc = prv_server_execute;
}
return serverObj;
}
lwm2m_object_t * get_object_firmware()
{
/*
* The get_object_firmware function create the object itself and return a pointer to the structure that represent it.
*/
lwm2m_object_t * firmwareObj;
firmwareObj = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != firmwareObj)
{
memset(firmwareObj, 0, sizeof(lwm2m_object_t));
/*
* It assign his unique ID
* The 5 is the standard ID for the optional object "Object firmware".
*/
firmwareObj->objID = 5;
/*
* And the private function that will access the object.
* Those function will be called when a read/write/execute query is made by the server. In fact the library don't need to
* know the resources of the object, only the server does.
*/
firmwareObj->readFunc = prv_firmware_read;
firmwareObj->writeFunc = prv_firmware_write;
firmwareObj->executeFunc = prv_firmware_execute;
firmwareObj->userData = lwm2m_malloc(sizeof(firmware_data_t));
firmwareObj->closeFunc = prv_firmware_close;
firmwareObj->printFunc = prv_firmware_print;
/*
* Also some user data can be stored in the object with a private structure containing the needed variables
*/
if (NULL != firmwareObj->userData)
{
((firmware_data_t*)firmwareObj->userData)->state = 1;
((firmware_data_t*)firmwareObj->userData)->supported = 0;
((firmware_data_t*)firmwareObj->userData)->result = 0;
}
else
{
free(firmwareObj);
firmwareObj = NULL;
}
}
return firmwareObj;
}
static lwm2m_client_object_t * prv_decodeRegisterPayload(uint8_t * payload,
uint16_t payloadLength)
{
lwm2m_client_object_t * objList;
uint16_t id;
uint16_t instance;
uint16_t start;
uint16_t end;
int result;
objList = NULL;
start = 0;
while (start < payloadLength)
{
while (start < payloadLength && payload[start] == ' ') start++;
if (start == payloadLength) return objList;
end = start;
while (end < payloadLength && payload[end] != ',') end++;
result = prv_getId(payload + start, end - start, &id, &instance);
if (result != 0)
{
lwm2m_client_object_t * objectP;
objectP = (lwm2m_client_object_t *)lwm2m_list_find((lwm2m_list_t *)objList, id);
if (objectP == NULL)
{
objectP = (lwm2m_client_object_t *)lwm2m_malloc(sizeof(lwm2m_client_object_t));
memset(objectP, 0, sizeof(lwm2m_client_object_t));
if (objectP == NULL) return objList;
objectP->id = id;
objList = (lwm2m_client_object_t *)LWM2M_LIST_ADD(objList, objectP);
}
if (result == 2)
{
lwm2m_list_t * instanceP;
instanceP = lwm2m_list_find(objectP->instanceList, instance);
if (instanceP == NULL)
{
instanceP = (lwm2m_list_t *)lwm2m_malloc(sizeof(lwm2m_list_t));
memset(instanceP, 0, sizeof(lwm2m_list_t));
instanceP->id = instance;
objectP->instanceList = LWM2M_LIST_ADD(objectP->instanceList, instanceP);
}
}
}
start = end + 1;
}
return objList;
}
int lwm2m_add_object(lwm2m_context_t * contextP,
lwm2m_object_t * objectP)
{
uint16_t i;
lwm2m_object_t ** newList;
for (i = 0 ; i < contextP->numObject ; i++)
{
if (contextP->objectList[i]->objID == objectP->objID) return COAP_406_NOT_ACCEPTABLE;
}
newList = (lwm2m_object_t **)lwm2m_malloc((contextP->numObject + 1) * sizeof(lwm2m_object_t *));
if (newList == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
memcpy(newList, contextP->objectList, contextP->numObject * sizeof(lwm2m_object_t *));
newList[contextP->numObject] = objectP;
lwm2m_free(contextP->objectList);
contextP->objectList = newList;
contextP->numObject += 1;
if (contextP->state == STATE_READY)
{
return lwm2m_update_registration(contextP, 0, true);
}
return COAP_NO_ERROR;
}
static void prv_backup_objects(lwm2m_context_t * context)
{
uint16_t i;
for (i = 0; i < BACKUP_OBJECT_COUNT; i++) {
if (NULL != backupObjectArray[i]) {
switch (backupObjectArray[i]->objID)
{
case LWM2M_SECURITY_OBJECT_ID:
clean_security_object(backupObjectArray[i]);
lwm2m_free(backupObjectArray[i]);
break;
case LWM2M_SERVER_OBJECT_ID:
clean_server_object(backupObjectArray[i]);
lwm2m_free(backupObjectArray[i]);
break;
default:
break;
}
}
backupObjectArray[i] = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
if(backupObjectArray[i] != NULL)
memset(backupObjectArray[i], 0, sizeof(lwm2m_object_t));
}
/*
* Backup content of objects 0 (security) and 1 (server)
*/
copy_security_object(backupObjectArray[0], (lwm2m_object_t *)LWM2M_LIST_FIND(context->objectList, LWM2M_SECURITY_OBJECT_ID));
copy_server_object(backupObjectArray[1], (lwm2m_object_t *)LWM2M_LIST_FIND(context->objectList, LWM2M_SERVER_OBJECT_ID));
}
static void prv_backup_objects(lwm2m_context_t * context)
{
uint16_t i;
for (i = 0; i < BACKUP_OBJECT_COUNT; i++) {
if (NULL != backupObjectArray[i]) {
backupObjectArray[i]->closeFunc(backupObjectArray[i]);
lwm2m_free(backupObjectArray[i]);
}
backupObjectArray[i] = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
memset(backupObjectArray[i], 0, sizeof(lwm2m_object_t));
}
/*
* Backup content of objects 0 (security) and 1 (server)
*/
for (i = 0; i < context->numObject; i++) {
lwm2m_object_t * object = context->objectList[i];
if (NULL != object) {
switch (object->objID)
{
case LWM2M_SECURITY_OBJECT_ID:
copy_security_object(backupObjectArray[0], object);
break;
case LWM2M_SERVER_OBJECT_ID:
copy_server_object(backupObjectArray[1], object);
break;
default:
break;
}
}
}
}
int lwm2m_bootstrap_delete(lwm2m_context_t * contextP,
void * sessionH,
lwm2m_uri_t * uriP)
{
lwm2m_transaction_t * transaction;
bs_data_t * dataP;
LOG_URI(uriP);
transaction = transaction_new(sessionH, COAP_DELETE, NULL, uriP, contextP->nextMID++, 4, NULL);
if (transaction == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
dataP = (bs_data_t *)lwm2m_malloc(sizeof(bs_data_t));
if (dataP == NULL)
{
transaction_free(transaction);
return COAP_500_INTERNAL_SERVER_ERROR;
}
if (uriP == NULL)
{
LWM2M_URI_RESET(&dataP->uri);
}
else
{
memcpy(&dataP->uri, uriP, sizeof(lwm2m_uri_t));
}
dataP->callback = contextP->bootstrapCallback;
dataP->userData = contextP->bootstrapUserData;
transaction->callback = prv_resultCallback;
transaction->userData = (void *)dataP;
contextP->transactionList = (lwm2m_transaction_t *)LWM2M_LIST_ADD(contextP->transactionList, transaction);
return transaction_send(contextP, transaction);
}
static uint8_t prv_server_create(uint16_t instanceId,
int numData,
lwm2m_data_t * dataArray,
lwm2m_object_t * objectP)
{
server_instance_t * serverInstance;
uint8_t result;
serverInstance = (server_instance_t *)lwm2m_malloc(sizeof(server_instance_t));
if (NULL == serverInstance) return COAP_500_INTERNAL_SERVER_ERROR;
memset(serverInstance, 0, sizeof(server_instance_t));
serverInstance->instanceId = instanceId;
objectP->instanceList = LWM2M_LIST_ADD(objectP->instanceList, serverInstance);
result = prv_server_write(instanceId, numData, dataArray, objectP);
if (result != COAP_204_CHANGED)
{
(void)prv_server_delete(instanceId, objectP);
}
else
{
result = COAP_201_CREATED;
}
return result;
}
void copy_server_object(lwm2m_object_t * objectDest, lwm2m_object_t * objectSrc)
{
memcpy(objectDest, objectSrc, sizeof(lwm2m_object_t));
objectDest->instanceList = NULL;
objectDest->userData = NULL;
server_instance_t * instanceSrc = (server_instance_t *)objectSrc->instanceList;
server_instance_t * previousInstanceDest = NULL;
while (instanceSrc != NULL)
{
server_instance_t * instanceDest = (server_instance_t *)lwm2m_malloc(sizeof(server_instance_t));
if (NULL == instanceDest)
{
return;
}
memcpy(instanceDest, instanceSrc, sizeof(server_instance_t));
// not sure it's necessary:
strcpy(instanceDest->binding, instanceSrc->binding);
instanceSrc = (server_instance_t *)instanceSrc->next;
if (previousInstanceDest == NULL)
{
objectDest->instanceList = (lwm2m_list_t *)instanceDest;
}
else
{
previousInstanceDest->next = instanceDest;
}
previousInstanceDest = instanceDest;
}
}
bool acc_ctrl_obj_add_inst (lwm2m_object_t* accCtrlObjP, uint16_t instId,
uint16_t acObjectId, uint16_t acObjInstId, uint16_t acOwner)
{
bool ret = false;
if (NULL == accCtrlObjP)
{
return ret;
}
else
{
// create an access control object instance
acc_ctrl_oi_t* accCtrlOiP;
accCtrlOiP = (acc_ctrl_oi_t *)lwm2m_malloc(sizeof(acc_ctrl_oi_t));
if (NULL == accCtrlOiP)
{
return ret;
}
else
{
memset(accCtrlOiP, 0, sizeof(acc_ctrl_oi_t));
// list: key
accCtrlOiP->objInstId = instId;
// object instance data:
accCtrlOiP->objectId = acObjectId;
accCtrlOiP->objectInstId = acObjInstId;
accCtrlOiP->accCtrlOwner = acOwner;
accCtrlObjP->instanceList =
LWM2M_LIST_ADD(accCtrlObjP->instanceList, accCtrlOiP);
ret = true;
}
}
return ret;
}
static void prv_getParameters(multi_option_t * query,
char ** nameP)
{
const char * start;
int length;
*nameP = NULL;
while (query != NULL)
{
if (query->len > QUERY_LENGTH)
{
if (strncmp(query->data, QUERY_TEMPLATE, QUERY_LENGTH) == 0)
{
*nameP = (char *)lwm2m_malloc(query->len - QUERY_LENGTH + 1);
if (*nameP != NULL)
{
memcpy(*nameP, query->data + QUERY_LENGTH, query->len - QUERY_LENGTH);
(*nameP)[query->len - QUERY_LENGTH] = 0;
}
break;
}
}
query = query->next;
}
}
static uint8_t prv_create(uint16_t objInstId, int numData,
lwm2m_data_t * tlvArray, lwm2m_object_t * objectP)
{
acc_ctrl_oi_t * targetP;
uint8_t result;
targetP = (acc_ctrl_oi_t *)lwm2m_malloc(sizeof(acc_ctrl_oi_t));
if (NULL == targetP) return COAP_500_INTERNAL_SERVER_ERROR;
memset(targetP, 0, sizeof(acc_ctrl_oi_t));
targetP->objInstId = objInstId;
objectP->instanceList = LWM2M_LIST_ADD(objectP->instanceList, targetP);
result = prv_write_resources(objInstId, numData, tlvArray, objectP, true);
if (result != COAP_204_CHANGED)
{
(void)prv_delete(objInstId, objectP);
}
else
{
result = COAP_201_CREATED;
}
return result;
}
/*
* Create an empty multiple instance LWM2M Object: Access Control
*/
lwm2m_object_t * acc_ctrl_create_object(void)
{
/*
* The acc_ctrl_create_object() function creates an empty object
* and returns a pointer to the structure that represents it.
*/
lwm2m_object_t* accCtrlObj = NULL;
accCtrlObj = (lwm2m_object_t *) lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != accCtrlObj)
{
memset(accCtrlObj, 0, sizeof(lwm2m_object_t));
/*
* It assign his unique object ID
* The 2 is the standard ID for the optional object "Access Control".
*/
accCtrlObj->objID = ACC_CTRLOBJ_ID;
// Init callbacks, empty instanceList!
accCtrlObj->readFunc = prv_read;
accCtrlObj->writeFunc = prv_write;
accCtrlObj->createFunc = prv_create;
accCtrlObj->deleteFunc = prv_delete;
}
return accCtrlObj;
}
uint8_t bootstrap_handleRequest(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP,
void * fromSessionH,
coap_packet_t * message,
coap_packet_t * response)
{
uint8_t result;
char * name;
LOG_URI(uriP);
if (contextP->bootstrapCallback == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
if (message->code != COAP_POST) return COAP_400_BAD_REQUEST;
if (message->uri_query == NULL) return COAP_400_BAD_REQUEST;
if (message->payload != NULL) return COAP_400_BAD_REQUEST;
if (lwm2m_strncmp((char *)message->uri_query->data, QUERY_NAME, QUERY_NAME_LEN) != 0)
{
return COAP_400_BAD_REQUEST;
}
if (message->uri_query->len == QUERY_NAME_LEN) return COAP_400_BAD_REQUEST;
if (message->uri_query->next != NULL) return COAP_400_BAD_REQUEST;
name = (char *)lwm2m_malloc(message->uri_query->len - QUERY_NAME_LEN + 1);
if (name == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
memcpy(name, message->uri_query->data + QUERY_NAME_LEN, message->uri_query->len - QUERY_NAME_LEN);
name[message->uri_query->len - QUERY_NAME_LEN] = 0;
result = contextP->bootstrapCallback(fromSessionH, COAP_NO_ERROR, NULL, name, contextP->bootstrapUserData);
lwm2m_free(name);
return result;
}
int lwm2m_bootstrap_finish(lwm2m_context_t * contextP,
void * sessionH)
{
lwm2m_transaction_t * transaction;
bs_data_t * dataP;
LOG("Entering");
transaction = transaction_new(sessionH, COAP_POST, NULL, NULL, contextP->nextMID++, 4, NULL);
if (transaction == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
coap_set_header_uri_path(transaction->message, "/"URI_BOOTSTRAP_SEGMENT);
dataP = (bs_data_t *)lwm2m_malloc(sizeof(bs_data_t));
if (dataP == NULL)
{
transaction_free(transaction);
return COAP_500_INTERNAL_SERVER_ERROR;
}
dataP->isUri = false;
dataP->callback = contextP->bootstrapCallback;
dataP->userData = contextP->bootstrapUserData;
transaction->callback = prv_resultCallback;
transaction->userData = (void *)dataP;
contextP->transactionList = (lwm2m_transaction_t *)LWM2M_LIST_ADD(contextP->transactionList, transaction);
return transaction_send(contextP, transaction);
}
int lwm2m_bootstrap_delete(lwm2m_context_t * contextP,
void * sessionH,
lwm2m_uri_t * uriP)
{
lwm2m_transaction_t * transaction;
bs_data_t * dataP;
transaction = transaction_new(COAP_TYPE_CON, COAP_DELETE, NULL, uriP, contextP->nextMID++, 4, NULL, ENDPOINT_UNKNOWN, sessionH);
if (transaction == NULL) return INTERNAL_SERVER_ERROR_5_00;
dataP = (bs_data_t *)lwm2m_malloc(sizeof(bs_data_t));
if (dataP == NULL)
{
transaction_free(transaction);
return COAP_500_INTERNAL_SERVER_ERROR;
}
if (uriP == NULL)
{
dataP->isUri = false;
}
else
{
dataP->isUri = true;
memcpy(&dataP->uri, uriP, sizeof(lwm2m_uri_t));
}
dataP->callback = contextP->bootstrapCallback;
dataP->userData = contextP->bootstrapUserData;
transaction->callback = bs_result_callback;
transaction->userData = (void *)dataP;
contextP->transactionList = (lwm2m_transaction_t *)LWM2M_LIST_ADD(contextP->transactionList, transaction);
return transaction_send(contextP, transaction);
}
static uint8_t prv_create(uint16_t instanceId,
int numData,
lwm2m_data_t * dataArray,
lwm2m_object_t * objectP)
{
prv_instance_t * targetP;
uint8_t result;
targetP = (prv_instance_t *)lwm2m_malloc(sizeof(prv_instance_t));
if (NULL == targetP) return COAP_500_INTERNAL_SERVER_ERROR;
memset(targetP, 0, sizeof(prv_instance_t));
targetP->shortID = instanceId;
objectP->instanceList = LWM2M_LIST_ADD(objectP->instanceList, targetP);
result = prv_write(instanceId, numData, dataArray, objectP);
if (result != COAP_204_CHANGED)
{
(void)prv_delete(instanceId, objectP);
}
else
{
result = COAP_201_CREATED;
}
return result;
}
coap_status_t handle_observe_request(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP,
uint8_t * fromAddr,
size_t fromAddrLen,
coap_packet_t * message,
coap_packet_t * response)
{
lwm2m_observed_t * observedP;
lwm2m_watcher_t * watcherP;
lwm2m_server_t * serverP;
LOG("handle_observe_request()\r\n");
if (!LWM2M_URI_IS_SET_INSTANCE(uriP) && LWM2M_URI_IS_SET_RESOURCE(uriP)) return COAP_400_BAD_REQUEST;
if (message->token_len == 0) return COAP_400_BAD_REQUEST;
serverP = prv_findServer(contextP, fromAddr, fromAddrLen);
if (serverP == NULL || serverP->status != STATE_REGISTERED) return COAP_401_UNAUTHORIZED;
observedP = prv_findObserved(contextP, uriP);
if (observedP == NULL)
{
observedP = (lwm2m_observed_t *)lwm2m_malloc(sizeof(lwm2m_observed_t));
if (observedP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
memset(observedP, 0, sizeof(lwm2m_observed_t));
memcpy(&(observedP->uri), uriP, sizeof(lwm2m_uri_t));
observedP->next = contextP->observedList;
contextP->observedList = observedP;
}
watcherP = prv_findWatcher(observedP, serverP);
if (watcherP == NULL)
{
watcherP = (lwm2m_watcher_t *)lwm2m_malloc(sizeof(lwm2m_watcher_t));
if (watcherP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
memset(watcherP, 0, sizeof(lwm2m_watcher_t));
watcherP->server = serverP;
watcherP->tokenLen = message->token_len;
memcpy(watcherP->token, message->token, message->token_len);
watcherP->next = observedP->watcherList;
observedP->watcherList = watcherP;
}
coap_set_header_observe(response, watcherP->counter++);
return COAP_205_CONTENT;
}
int lwm2m_observe_cancel(lwm2m_context_t * contextP,
uint16_t clientID,
lwm2m_uri_t * uriP,
lwm2m_result_callback_t callback,
void * userData)
{
lwm2m_client_t * clientP;
lwm2m_observation_t * observationP;
clientP = (lwm2m_client_t *)lwm2m_list_find((lwm2m_list_t *)contextP->clientList, clientID);
if (clientP == NULL) return COAP_404_NOT_FOUND;
observationP = prv_findObservationByURI(clientP, uriP);
if (observationP == NULL) return COAP_404_NOT_FOUND;
switch (observationP->status)
{
case STATE_REGISTERED:
{
lwm2m_transaction_t * transactionP;
cancellation_data_t * cancelP;
transactionP = transaction_new(COAP_TYPE_CON, COAP_GET, clientP->altPath, uriP, contextP->nextMID++, 0, NULL, ENDPOINT_CLIENT, (void *)clientP);
if (transactionP == NULL)
{
return COAP_500_INTERNAL_SERVER_ERROR;
}
cancelP = (cancellation_data_t *)lwm2m_malloc(sizeof(cancellation_data_t));
if (cancelP == NULL)
{
lwm2m_free(transactionP);
return COAP_500_INTERNAL_SERVER_ERROR;
}
coap_set_header_observe(transactionP->message, 1);
cancelP->observationP = observationP;
cancelP->callbackP = callback;
cancelP->userDataP = userData;
transactionP->callback = prv_obsCancelRequestCallback;
transactionP->userData = (void *)cancelP;
contextP->transactionList = (lwm2m_transaction_t *)LWM2M_LIST_ADD(contextP->transactionList, transactionP);
return transaction_send(contextP, transactionP);
}
case STATE_REG_PENDING:
observationP->status = STATE_DEREG_PENDING;
break;
default:
// Should not happen
break;
}
return COAP_NO_ERROR;
}
lwm2m_object_t * get_object_device()
{
/*
* The get_object_device function create the object itself and return a pointer to the structure that represent it.
*/
lwm2m_object_t * deviceObj;
deviceObj = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != deviceObj)
{
memset(deviceObj, 0, sizeof(lwm2m_object_t));
/*
* It assigns his unique ID
* The 3 is the standard ID for the mandatory object "Object device".
*/
deviceObj->objID = LWM2M_DEVICE_OBJECT_ID;
/*
* and its unique instance
*
*/
deviceObj->instanceList = (lwm2m_list_t *)lwm2m_malloc(sizeof(lwm2m_list_t));
if (NULL != deviceObj->instanceList)
{
memset(deviceObj->instanceList, 0, sizeof(lwm2m_list_t));
}
else
{
lwm2m_free(deviceObj);
return NULL;
}
/*
* And the private function that will access the object.
* Those function will be called when a read/write/execute query is made by the server. In fact the library don't need to
* know the resources of the object, only the server does.
*/
deviceObj->readFunc = prv_device_read;
deviceObj->executeFunc = prv_device_execute;
}
return deviceObj;
}
lwm2m_object_t * get_security_object(int serverId, const char* serverUri, bool isBootstrap)
{
lwm2m_object_t * securityObj;
securityObj = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));
if (NULL != securityObj)
{
security_instance_t * targetP;
memset(securityObj, 0, sizeof(lwm2m_object_t));
securityObj->objID = 0;
// Manually create an hardcoded instance
targetP = (security_instance_t *)lwm2m_malloc(sizeof(security_instance_t));
if (NULL == targetP)
{
lwm2m_free(securityObj);
return NULL;
}
memset(targetP, 0, sizeof(security_instance_t));
targetP->instanceId = 0;
targetP->uri = (char*)lwm2m_malloc(strlen(serverUri)+1);
strcpy(targetP->uri, serverUri);
targetP->isBootstrap = isBootstrap;
targetP->shortID = serverId;
targetP->clientHoldOffTime = 10;
securityObj->instanceList = LWM2M_LIST_ADD(securityObj->instanceList, targetP);
securityObj->readFunc = prv_security_read;
#ifdef LWM2M_BOOTSTRAP
securityObj->writeFunc = prv_security_write;
securityObj->createFunc = prv_security_create;
securityObj->deleteFunc = prv_security_delete;
#endif
securityObj->closeFunc = prv_security_close;
}
return securityObj;
}
static lwm2m_watcher_t * prv_getWatcher(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP,
lwm2m_server_t * serverP)
{
lwm2m_observed_t * observedP;
bool allocatedObserver;
lwm2m_watcher_t * watcherP;
allocatedObserver = false;
observedP = prv_findObserved(contextP, uriP);
if (observedP == NULL)
{
observedP = (lwm2m_observed_t *)lwm2m_malloc(sizeof(lwm2m_observed_t));
if (observedP == NULL) return NULL;
allocatedObserver = true;
memset(observedP, 0, sizeof(lwm2m_observed_t));
memcpy(&(observedP->uri), uriP, sizeof(lwm2m_uri_t));
observedP->next = contextP->observedList;
contextP->observedList = observedP;
}
watcherP = prv_findWatcher(observedP, serverP);
if (watcherP == NULL)
{
watcherP = (lwm2m_watcher_t *)lwm2m_malloc(sizeof(lwm2m_watcher_t));
if (watcherP == NULL)
{
if (allocatedObserver == true)
{
lwm2m_free(observedP);
}
return NULL;
}
memset(watcherP, 0, sizeof(lwm2m_watcher_t));
watcherP->active = false;
watcherP->server = serverP;
watcherP->next = observedP->watcherList;
observedP->watcherList = watcherP;
}
return watcherP;
}