static uint8_t prv_get_value(lwm2m_data_t * dataP,
security_instance_t * targetP)
{
switch (dataP->id)
{
case LWM2M_SECURITY_URI_ID:
lwm2m_data_encode_string(targetP->uri, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_BOOTSTRAP_ID:
lwm2m_data_encode_bool(targetP->isBootstrap, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SECURITY_ID:
lwm2m_data_encode_int(targetP->securityMode, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_PUBLIC_KEY_ID:
lwm2m_data_encode_opaque(targetP->publicIdentity, targetP->publicIdLen, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SERVER_PUBLIC_KEY_ID:
lwm2m_data_encode_opaque(targetP->serverPublicKey, targetP->serverPublicKeyLen, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SECRET_KEY_ID:
lwm2m_data_encode_opaque(targetP->secretKey, targetP->secretKeyLen, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SMS_SECURITY_ID:
lwm2m_data_encode_int(targetP->smsSecurityMode, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SMS_KEY_PARAM_ID:
lwm2m_data_encode_opaque(targetP->smsParams, targetP->smsParamsLen, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SMS_SECRET_KEY_ID:
lwm2m_data_encode_opaque(targetP->smsSecret, targetP->smsSecretLen, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SMS_SERVER_NUMBER_ID:
lwm2m_data_encode_int(0, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_SHORT_SERVER_ID:
lwm2m_data_encode_int(targetP->shortID, dataP);
return COAP_205_CONTENT;
case LWM2M_SECURITY_HOLD_OFF_ID:
lwm2m_data_encode_int(targetP->clientHoldOffTime, dataP);
return COAP_205_CONTENT;
default:
return COAP_404_NOT_FOUND;
}
}
static uint8_t prv_get_value(lwm2m_data_t * dataP,
server_instance_t * targetP)
{
// There are no multiple instance resources
dataP->type = LWM2M_TYPE_RESOURCE;
switch (dataP->id)
{
case LWM2M_SERVER_SHORT_ID_ID:
lwm2m_data_encode_int(targetP->shortServerId, dataP);
if (0 != dataP->length) return COAP_205_CONTENT;
else return COAP_500_INTERNAL_SERVER_ERROR;
case LWM2M_SERVER_LIFETIME_ID:
lwm2m_data_encode_int(targetP->lifetime, dataP);
if (0 != dataP->length) return COAP_205_CONTENT;
else return COAP_500_INTERNAL_SERVER_ERROR;
case LWM2M_SERVER_MIN_PERIOD_ID:
lwm2m_data_encode_int(targetP->minPeriod, dataP);
if (0 != dataP->length) return COAP_205_CONTENT;
else return COAP_500_INTERNAL_SERVER_ERROR;
case LWM2M_SERVER_MAX_PERIOD_ID:
lwm2m_data_encode_int(targetP->maxPeriod, dataP);
if (0 != dataP->length) return COAP_205_CONTENT;
else return COAP_500_INTERNAL_SERVER_ERROR;
case LWM2M_SERVER_DISABLE_ID:
return COAP_405_METHOD_NOT_ALLOWED;
case LWM2M_SERVER_STORING_ID:
lwm2m_data_encode_bool(targetP->storing, dataP);
if (0 != dataP->length) return COAP_205_CONTENT;
else return COAP_500_INTERNAL_SERVER_ERROR;
case LWM2M_SERVER_BINDING_ID:
dataP->value = (uint8_t*)targetP->binding;
dataP->length = strlen(targetP->binding);
dataP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
dataP->dataType = LWM2M_TYPE_STRING;
return COAP_205_CONTENT;
case LWM2M_SERVER_UPDATE_ID:
return COAP_405_METHOD_NOT_ALLOWED;
default:
return COAP_404_NOT_FOUND;
}
}
/**
implementation for all read-able resources
*/
static uint8_t prv_res2tlv(lwm2m_data_t* dataP,
location_data_t* locDataP)
{
//-------------------------------------------------------------------- JH --
uint8_t ret = COAP_205_CONTENT;
switch (dataP->id) // location resourceId
{
case RES_M_LATITUDE:
lwm2m_data_encode_float(locDataP->latitude, dataP);
break;
case RES_M_LONGITUDE:
lwm2m_data_encode_float(locDataP->longitude, dataP);
break;
case RES_O_ALTITUDE:
lwm2m_data_encode_float(locDataP->altitude, dataP);
break;
case RES_O_RADIUS:
lwm2m_data_encode_float(locDataP->radius, dataP);
break;
case RES_O_VELOCITY:
lwm2m_data_encode_string((const char*)locDataP->velocity, dataP);
break;
case RES_M_TIMESTAMP:
lwm2m_data_encode_int(locDataP->timestamp, dataP);
break;
case RES_O_SPEED:
lwm2m_data_encode_float(locDataP->speed, dataP);
break;
default:
ret = COAP_404_NOT_FOUND;
break;
}
return ret;
}
static uint8_t prv_read(uint16_t instanceId,
int * numDataP,
lwm2m_data_t ** dataArrayP,
lwm2m_object_t * objectP)
{
prv_instance_t * targetP;
int i;
targetP = (prv_instance_t *)lwm2m_list_find(objectP->instanceList, instanceId);
if (NULL == targetP) return COAP_404_NOT_FOUND;
if (*numDataP == 0)
{
*dataArrayP = lwm2m_data_new(3);
if (*dataArrayP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
*numDataP = 3;
(*dataArrayP)[0].id = 1;
(*dataArrayP)[1].id = 3;
(*dataArrayP)[2].id = 4;
}
for (i = 0 ; i < *numDataP ; i++)
{
switch ((*dataArrayP)[i].id)
{
case 1:
(*dataArrayP)[i].type = LWM2M_TYPE_RESOURCE;
lwm2m_data_encode_int(targetP->test, *dataArrayP + i);
break;
case 2:
return COAP_405_METHOD_NOT_ALLOWED;
case 3:
(*dataArrayP)[i].type = LWM2M_TYPE_RESOURCE;
lwm2m_data_encode_float(targetP->dec, *dataArrayP + i);
break;
case 4:
(*dataArrayP)[i].type = LWM2M_TYPE_RESOURCE;
lwm2m_data_encode_int(targetP->sig, *dataArrayP + i);
break;
default:
return COAP_404_NOT_FOUND;
}
if ((*dataArrayP)[i].length == 0) return COAP_500_INTERNAL_SERVER_ERROR;
}
return COAP_205_CONTENT;
}
static uint8_t prv_set_tlv(lwm2m_data_t* dataP, acc_ctrl_oi_t* accCtrlOiP)
{
switch (dataP->id) {
case RES_M_OBJECT_ID:
lwm2m_data_encode_int(accCtrlOiP->objectId, dataP);
return COAP_205_CONTENT;
case RES_M_OBJECT_INSTANCE_ID:
lwm2m_data_encode_int(accCtrlOiP->objectInstId, dataP);
return COAP_205_CONTENT;
case RES_O_ACL:
{
int ri;
acc_ctrl_ri_t* accCtrlRiP;
for (accCtrlRiP =accCtrlOiP->accCtrlValList, ri=0;
accCtrlRiP!=NULL;
accCtrlRiP = accCtrlRiP->next, ri++);
if (ri==0) // no values!
{
return COAP_404_NOT_FOUND;
}
else
{
lwm2m_data_t* subTlvP = lwm2m_data_new(ri);
if (subTlvP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
for (accCtrlRiP = accCtrlOiP->accCtrlValList, ri = 0;
accCtrlRiP!= NULL;
accCtrlRiP = accCtrlRiP->next, ri++)
{
subTlvP[ri].id = accCtrlRiP->resInstId;
lwm2m_data_encode_int(accCtrlRiP->accCtrlValue, &subTlvP[ri]);
}
lwm2m_data_encode_instances(subTlvP, 2, dataP);
return COAP_205_CONTENT;
}
}
case RES_M_ACCESS_CONTROL_OWNER:
lwm2m_data_encode_int(accCtrlOiP->accCtrlOwner, dataP);
return COAP_205_CONTENT;
default:
return COAP_404_NOT_FOUND ;
}
}
/**
implementation for all read-able resources
*/
static uint8_t prv_res2tlv(lwm2m_data_t* dataP,
location_data_t* locDataP)
{
//-------------------------------------------------------------------- JH --
uint8_t ret = COAP_205_CONTENT;
switch (dataP->id) // location resourceId
{
case RES_M_LATITUDE:
dataP->value = (uint8_t*)locDataP->latitude;
dataP->length = strlen(locDataP->latitude);
dataP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
dataP->type = LWM2M_TYPE_RESOURCE;
dataP->dataType = LWM2M_TYPE_STRING;
break;
case RES_M_LONGITUDE:
dataP->value = (uint8_t*)locDataP->longitude;
dataP->length = strlen(locDataP->latitude);
dataP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
dataP->type = LWM2M_TYPE_RESOURCE;
dataP->dataType = LWM2M_TYPE_STRING;
break;
case RES_O_ALTITUDE:
dataP->value = (uint8_t*)locDataP->altitude;
dataP->length = strlen(locDataP->altitude);
dataP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
dataP->type = LWM2M_TYPE_RESOURCE;
dataP->dataType = LWM2M_TYPE_STRING;
break;
case RES_O_UNCERTAINTY:
dataP->value = (uint8_t*)locDataP->uncertainty;
dataP->length = strlen(locDataP->uncertainty);
dataP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
dataP->type = LWM2M_TYPE_RESOURCE;
dataP->dataType = LWM2M_TYPE_STRING;
break;
case RES_O_VELOCITY:
dataP->value = locDataP->velocity;
dataP->length = VELOCITY_OCTETS;
dataP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
dataP->type = LWM2M_TYPE_RESOURCE;
dataP->dataType = LWM2M_TYPE_OPAQUE;
break;
case RES_M_TIMESTAMP:
lwm2m_data_encode_int(locDataP->timestamp, dataP);
dataP->type = LWM2M_TYPE_RESOURCE;
dataP->dataType = LWM2M_TYPE_TIME;
break;
default:
ret = COAP_404_NOT_FOUND;
break;
}
return ret;
}
static uint8_t prv_set_tlv(lwm2m_data_t *dataP, conn_s_data_t *connStDataP)
{
switch (dataP->id) {
case RES_O_SMS_TX_COUNTER:
lwm2m_data_encode_int(connStDataP->smsTxCounter, dataP);
return COAP_205_CONTENT;
break;
case RES_O_SMS_RX_COUNTER:
lwm2m_data_encode_int(connStDataP->smsRxCounter, dataP);
return COAP_205_CONTENT;
break;
case RES_O_TX_DATA:
lwm2m_data_encode_int(connStDataP->txDataByte / 1024, dataP);
return COAP_205_CONTENT;
break;
case RES_O_RX_DATA:
lwm2m_data_encode_int(connStDataP->rxDataByte / 1024, dataP);
return COAP_205_CONTENT;
break;
case RES_O_MAX_MESSAGE_SIZE:
lwm2m_data_encode_int(connStDataP->maxMessageSize, dataP);
return COAP_205_CONTENT;
break;
case RES_O_AVERAGE_MESSAGE_SIZE:
lwm2m_data_encode_int(connStDataP->avrMessageSize, dataP);
return COAP_205_CONTENT;
break;
default:
return COAP_404_NOT_FOUND ;
}
}
static int prv_convertRecord(_record_t * recordArray,
int count,
lwm2m_data_t ** dataP)
{
int index;
int tlvIndex;
lwm2m_data_t * tlvP;
// may be overkill
tlvP = lwm2m_data_new(count);
if (NULL == tlvP) return -1;
tlvIndex = 0;
for (index = 0 ; index < count ; index++)
{
lwm2m_data_t * targetP;
if (recordArray[index].resInstId == LWM2M_MAX_ID)
{
targetP = tlvP + tlvIndex;
targetP->type = LWM2M_TYPE_RESOURCE;
targetP->id = recordArray[index].resId;
tlvIndex++;
}
else
{
int resIndex;
resIndex = 0;
while (resIndex < tlvIndex
&& tlvP[resIndex].id != recordArray[index].resId)
{
resIndex++;
}
if (resIndex == tlvIndex)
{
targetP = lwm2m_data_new(1);
if (NULL == targetP) goto error;
tlvP[resIndex].type = LWM2M_TYPE_MULTIPLE_RESOURCE;
tlvP[resIndex].id = recordArray[index].resId;
tlvP[resIndex].length = 1;
tlvP[resIndex].value = (uint8_t *)targetP;
tlvIndex++;
}
else
{
targetP = lwm2m_data_new(tlvP[resIndex].length + 1);
if (NULL == targetP) goto error;
memcpy(targetP + 1, tlvP[resIndex].value, tlvP[resIndex].length * sizeof(lwm2m_data_t));
lwm2m_free(tlvP[resIndex].value); // do not use lwm2m_data_free() to preserve value pointers
tlvP[resIndex].value = (uint8_t *)targetP;
tlvP[resIndex].length++;
}
targetP->type = LWM2M_TYPE_RESOURCE_INSTANCE;
targetP->id = recordArray[index].resInstId;
}
switch (recordArray[index].type)
{
case _TYPE_FALSE:
lwm2m_data_encode_bool(false, targetP);
break;
case _TYPE_TRUE:
lwm2m_data_encode_bool(true, targetP);
break;
case _TYPE_FLOAT:
{
size_t i;
i = 0;
while (i < recordArray[index].valueLen
&& recordArray[index].value[i] != '.')
{
i++;
}
if (i == recordArray[index].valueLen)
{
int64_t value;
if ( 1 != lwm2m_PlainTextToInt64(recordArray[index].value,
recordArray[index].valueLen,
&value))
{
goto error;
}
lwm2m_data_encode_int(value, targetP);
}
else
{
double value;
if ( 1 != lwm2m_PlainTextToFloat64(recordArray[index].value,
recordArray[index].valueLen,
&value))
{
goto error;
}
lwm2m_data_encode_float(value, targetP);
}
}
break;
// TODO: Copy string instead of pointing to it
case _TYPE_STRING:
targetP->flags = LWM2M_TLV_FLAG_STATIC_DATA | LWM2M_TLV_FLAG_TEXT_FORMAT;
targetP->dataType = LWM2M_TYPE_STRING; // or opaque ?
targetP->length = recordArray[index].valueLen;
targetP->value = recordArray[index].value;
break;
case _TYPE_UNSET:
default:
goto error;
}
}
*dataP = tlvP;
return tlvIndex;
error:
lwm2m_data_free(count, tlvP);
return -1;
}
static void prv_create_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char * end = NULL;
int result;
int64_t value;
uint8_t * temp_buffer = NULL;
int temp_length = 0;
lwm2m_media_type_t format = LWM2M_CONTENT_TEXT;
//Get Client ID
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
//Get Uri
buffer = get_next_arg(buffer, &end);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
//Get Data to Post
buffer = get_next_arg(end, &end);
if (buffer[0] == 0) goto syntax_error;
if (!check_end_of_args(end)) goto syntax_error;
// TLV
/* Client dependent part */
if (uri.objectId == 1024)
{
lwm2m_data_t * dataP;
dataP = lwm2m_data_new(1);
if (dataP == NULL)
{
fprintf(stdout, "Allocation error !");
return;
}
lwm2m_data_encode_int(value, dataP);
dataP->id = 1;
format = LWM2M_CONTENT_TLV;
temp_length = lwm2m_data_serialize(NULL, 1, dataP, &format, &temp_buffer);
}
/* End Client dependent part*/
//Create
result = lwm2m_dm_create(lwm2mH, clientId, &uri, format, temp_buffer, temp_length, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
prv_print_error(result);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
static int prv_add_server(bs_info_t * infoP,
read_server_t * dataP)
{
lwm2m_data_t * tlvP;
int size;
bs_server_tlv_t * serverP;
lwm2m_media_type_t format;
switch (dataP->securityMode)
{
case LWM2M_SECURITY_MODE_NONE:
size = 4;
break;
case LWM2M_SECURITY_MODE_PRE_SHARED_KEY:
size = 6;
break;
case LWM2M_SECURITY_MODE_RAW_PUBLIC_KEY:
case LWM2M_SECURITY_MODE_CERTIFICATE:
size = 7;
break;
default:
return -1;
}
serverP = (bs_server_tlv_t *)lwm2m_malloc(sizeof(bs_server_tlv_t));
if (serverP == NULL) return -1;
memset(serverP, 0, sizeof(bs_server_tlv_t));
serverP->id = dataP->id;
tlvP = lwm2m_data_new(size);
if (tlvP == NULL) goto error;
// LWM2M Server URI
tlvP[0].id = LWM2M_SECURITY_URI_ID;
lwm2m_data_encode_string(dataP->uri, tlvP);
// Bootstrap Server
tlvP[1].id = LWM2M_SECURITY_BOOTSTRAP_ID;
lwm2m_data_encode_bool(dataP->isBootstrap, tlvP + 1);
// Short Server ID
tlvP[2].id = LWM2M_SECURITY_SHORT_SERVER_ID;
lwm2m_data_encode_int(dataP->id, tlvP + 2);
// Security Mode
tlvP[3].id = LWM2M_SECURITY_SECURITY_ID;
lwm2m_data_encode_int(dataP->securityMode, tlvP + 3);
if (size > 4)
{
tlvP[4].id = LWM2M_SECURITY_PUBLIC_KEY_ID;
lwm2m_data_encode_opaque(dataP->publicKey, dataP->publicKeyLen, tlvP + 4);
tlvP[5].id = LWM2M_SECURITY_SECRET_KEY_ID;
lwm2m_data_encode_opaque(dataP->secretKey, dataP->secretKeyLen, tlvP + 5);
if (size == 7)
{
tlvP[6].id = LWM2M_SECURITY_SERVER_PUBLIC_KEY_ID;
lwm2m_data_encode_opaque(dataP->serverKey, dataP->serverKeyLen, tlvP + 5);
}
}
format = LWM2M_CONTENT_TLV;
serverP->securityLen = lwm2m_data_serialize(NULL, size, tlvP, &format, &(serverP->securityData));
if (serverP->securityLen <= 0) goto error;
lwm2m_data_free(size, tlvP);
if (dataP->isBootstrap == false)
{
size = 4;
tlvP = lwm2m_data_new(size);
if (tlvP == NULL) goto error;
// Short Server ID
tlvP[0].id = LWM2M_SERVER_SHORT_ID_ID;
lwm2m_data_encode_int(dataP->id, tlvP);
// Lifetime
tlvP[1].id = LWM2M_SERVER_LIFETIME_ID;
lwm2m_data_encode_int(dataP->lifetime, tlvP + 1);
// Notification Storing
tlvP[2].id = LWM2M_SERVER_STORING_ID;
lwm2m_data_encode_bool(false, tlvP + 2);
// Binding
tlvP[3].id = LWM2M_SERVER_BINDING_ID;
lwm2m_data_encode_string("U", tlvP + 3);
serverP->serverLen = lwm2m_data_serialize(NULL, size, tlvP, &format, &(serverP->serverData));
if (serverP->serverLen <= 0) goto error;
lwm2m_data_free(size, tlvP);
}
infoP->serverList = (bs_server_tlv_t *)LWM2M_LIST_ADD(infoP->serverList, serverP);
return 0;
error:
if (tlvP != NULL) lwm2m_data_free(size, tlvP);
if (serverP->securityData != NULL) lwm2m_free(serverP->securityData);
if (serverP->serverData != NULL) lwm2m_free(serverP->serverData);
lwm2m_free(serverP);
return -1;
}
static uint8_t prv_firmware_read(uint16_t instanceId,
int * numDataP,
lwm2m_data_t ** dataArrayP,
lwm2m_object_t * objectP)
{
int i;
uint8_t result;
firmware_data_t * data = (firmware_data_t*)(objectP->userData);
// this is a single instance object
if (instanceId != 0)
{
return COAP_404_NOT_FOUND;
}
// is the server asking for the full object ?
if (*numDataP == 0)
{
*dataArrayP = lwm2m_data_new(3);
if (*dataArrayP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
*numDataP = 6;
(*dataArrayP)[0].id = 3;
(*dataArrayP)[1].id = 5;
(*dataArrayP)[2].id = 6;
(*dataArrayP)[3].id = 7;
(*dataArrayP)[4].id = 8;
(*dataArrayP)[5].id = 9;
}
i = 0;
do
{
switch ((*dataArrayP)[i].id)
{
case RES_M_PACKAGE:
case RES_M_PACKAGE_URI:
case RES_M_UPDATE:
result = COAP_405_METHOD_NOT_ALLOWED;
break;
case RES_M_STATE:
// firmware update state (int)
lwm2m_data_encode_int(data->state, *dataArrayP + i);
result = COAP_205_CONTENT;
break;
case RES_M_UPDATE_RESULT:
lwm2m_data_encode_int(data->result, *dataArrayP + i);
result = COAP_205_CONTENT;
break;
case RES_O_PKG_NAME:
lwm2m_data_encode_string(data->pkg_name, *dataArrayP + i);
result = COAP_205_CONTENT;
break;
case RES_O_PKG_VERSION:
lwm2m_data_encode_string(data->pkg_version, *dataArrayP + i);
result = COAP_205_CONTENT;
break;
case RES_O_UPDATE_PROTOCOL:
{
int ri;
int num = 0;
lwm2m_data_t* subTlvP = NULL;
while ((num < LWM2M_FIRMWARE_PROTOCOL_NUM) &&
(data->protocol_support[num] != LWM2M_FIRMWARE_PROTOCOL_NULL))
num++;
if (num) {
subTlvP = lwm2m_data_new(num);
for (ri = 0; ri<num; ri++)
{
subTlvP[ri].id = ri;
lwm2m_data_encode_int(data->protocol_support[ri], subTlvP + ri);
}
} else {
/* If no protocol is provided, use CoAP as default (per spec) */
num = 1;
subTlvP = lwm2m_data_new(num);
subTlvP[0].id = 0;
lwm2m_data_encode_int(0, subTlvP);
}
lwm2m_data_encode_instances(subTlvP, num, *dataArrayP + i);
result = COAP_205_CONTENT;
break;
}
case RES_M_UPDATE_METHOD:
lwm2m_data_encode_int(data->delivery_method, *dataArrayP + i);
result = COAP_205_CONTENT;
break;
default:
result = COAP_404_NOT_FOUND;
}
i++;
} while (i < *numDataP && result == COAP_205_CONTENT);
return result;
}
static uint8_t prv_get_value(lwm2m_data_t * dataP,
server_instance_t * targetP)
{
switch (dataP->id)
{
case LWM2M_SERVER_SHORT_ID_ID:
lwm2m_data_encode_int(targetP->shortServerId, dataP);
return COAP_205_CONTENT;
case LWM2M_SERVER_LIFETIME_ID:
lwm2m_data_encode_int(targetP->lifetime, dataP);
return COAP_205_CONTENT;
case LWM2M_SERVER_MIN_PERIOD_ID:
lwm2m_data_encode_int(targetP->defaultMinPeriod, dataP);
return COAP_205_CONTENT;
case LWM2M_SERVER_MAX_PERIOD_ID:
lwm2m_data_encode_int(targetP->defaultMaxPeriod, dataP);
return COAP_205_CONTENT;
case LWM2M_SERVER_DISABLE_ID:
return COAP_405_METHOD_NOT_ALLOWED;
case LWM2M_SERVER_TIMEOUT_ID:
lwm2m_data_encode_int(targetP->disableTimeout, dataP);
return COAP_205_CONTENT;
case LWM2M_SERVER_STORING_ID:
lwm2m_data_encode_bool(targetP->storing, dataP);
return COAP_205_CONTENT;
case LWM2M_SERVER_BINDING_ID:
lwm2m_data_encode_string(targetP->binding, dataP);
return COAP_205_CONTENT;
case LWM2M_SERVER_UPDATE_ID:
return COAP_405_METHOD_NOT_ALLOWED;
#ifndef LWM2M_VERSION_1_0
case LWM2M_SERVER_REG_ORDER_ID:
if (targetP->registrationPriorityOrder >= 0)
{
lwm2m_data_encode_uint(targetP->registrationPriorityOrder, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
case LWM2M_SERVER_INITIAL_REG_DELAY_ID:
if (targetP->initialRegistrationDelayTimer >= 0)
{
lwm2m_data_encode_uint(targetP->initialRegistrationDelayTimer, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
case LWM2M_SERVER_REG_FAIL_BLOCK_ID:
if (targetP->registrationFailureBlock >= 0)
{
lwm2m_data_encode_bool(targetP->registrationFailureBlock > 0, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
case LWM2M_SERVER_REG_FAIL_BOOTSTRAP_ID:
if (targetP->bootstrapOnRegistrationFailure >= 0)
{
lwm2m_data_encode_bool(targetP->bootstrapOnRegistrationFailure > 0, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
case LWM2M_SERVER_COMM_RETRY_COUNT_ID:
if (targetP->communicationRetryCount >= 0)
{
lwm2m_data_encode_uint(targetP->communicationRetryCount, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
case LWM2M_SERVER_COMM_RETRY_TIMER_ID:
if (targetP->communicationRetryTimer >= 0)
{
lwm2m_data_encode_uint(targetP->communicationRetryTimer, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
case LWM2M_SERVER_SEQ_DELAY_TIMER_ID:
if (targetP->communicationSequenceDelayTimer >= 0)
{
lwm2m_data_encode_uint(targetP->communicationSequenceDelayTimer, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
case LWM2M_SERVER_SEQ_RETRY_COUNT_ID:
if (targetP->communicationSequenceRetryCount >= 0)
{
lwm2m_data_encode_uint(targetP->communicationSequenceRetryCount, dataP);
return COAP_205_CONTENT;
}
else
{
return COAP_404_NOT_FOUND;
}
#endif
default:
return COAP_404_NOT_FOUND;
}
}
static uint8_t prv_set_value(lwm2m_data_t * dataP,
conn_m_data_t * connDataP)
{
switch (dataP->id)
{
case RES_M_NETWORK_BEARER:
lwm2m_data_encode_int(VALUE_NETWORK_BEARER_GSM, dataP);
return COAP_205_CONTENT;
case RES_M_AVL_NETWORK_BEARER:
{
int riCnt = 1; // reduced to 1 instance to fit in one block size
lwm2m_data_t * subTlvP;
subTlvP = lwm2m_data_new(riCnt);
subTlvP[0].id = 0;
lwm2m_data_encode_int(VALUE_AVL_NETWORK_BEARER_1, subTlvP);
lwm2m_data_encode_instances(subTlvP, riCnt, dataP);
return COAP_205_CONTENT ;
}
case RES_M_RADIO_SIGNAL_STRENGTH: //s-int
lwm2m_data_encode_int(connDataP->signalStrength, dataP);
return COAP_205_CONTENT;
case RES_O_LINK_QUALITY: //s-int
lwm2m_data_encode_int(connDataP->linkQuality, dataP);
return COAP_205_CONTENT ;
case RES_M_IP_ADDRESSES:
{
int ri, riCnt = 1; // reduced to 1 instance to fit in one block size
lwm2m_data_t* subTlvP = lwm2m_data_new(riCnt);
for (ri = 0; ri < riCnt; ri++)
{
subTlvP[ri].id = ri;
lwm2m_data_encode_string(connDataP->ipAddresses[ri], subTlvP + ri);
}
lwm2m_data_encode_instances(subTlvP, riCnt, dataP);
return COAP_205_CONTENT ;
}
break;
case RES_O_ROUTER_IP_ADDRESS:
{
int ri, riCnt = 1; // reduced to 1 instance to fit in one block size
lwm2m_data_t* subTlvP = lwm2m_data_new(riCnt);
for (ri=0; ri<riCnt; ri++)
{
subTlvP[ri].id = ri;
lwm2m_data_encode_string(connDataP->routerIpAddresses[ri], subTlvP + ri);
}
lwm2m_data_encode_instances(subTlvP, riCnt, dataP);
return COAP_205_CONTENT ;
}
break;
case RES_O_LINK_UTILIZATION:
lwm2m_data_encode_int(connDataP->linkUtilization, dataP);
return COAP_205_CONTENT;
case RES_O_APN:
{
int riCnt = 1; // reduced to 1 instance to fit in one block size
lwm2m_data_t * subTlvP;
subTlvP = lwm2m_data_new(riCnt);
subTlvP[0].id = 0;
lwm2m_data_encode_string(VALUE_APN_1, subTlvP);
lwm2m_data_encode_instances(subTlvP, riCnt, dataP);
return COAP_205_CONTENT;
}
break;
case RES_O_CELL_ID:
lwm2m_data_encode_int(connDataP->cellId, dataP);
return COAP_205_CONTENT ;
case RES_O_SMNC:
lwm2m_data_encode_int(VALUE_SMNC, dataP);
return COAP_205_CONTENT ;
case RES_O_SMCC:
lwm2m_data_encode_int(VALUE_SMCC, dataP);
return COAP_205_CONTENT ;
default:
return COAP_404_NOT_FOUND ;
}
}
// Convert the resource from the top of the stack in dataP
// return 0 (COAP_NO_ERROR) if ok or COAP error if an error occurred (see liblwm2m.h)
static int prv_luaToResourceData(lua_State * L, uint16_t resourceid,
lwm2m_data_t * dataP, lwm2m_data_type_t type) {
int value_type = lua_type(L, -1);
switch (value_type) {
case LUA_TNIL:
dataP->id = resourceid;
dataP->value = NULL;
dataP->length = 0;
dataP->type = type;
break;
case LUA_TBOOLEAN:
dataP->id = resourceid;
dataP->type = type;
int64_t boolean = lua_toboolean(L, -1);
if (boolean)
lwm2m_data_encode_int(1,dataP);
else
lwm2m_data_encode_int(0,dataP);
break;
case LUA_TNUMBER:
dataP->id = resourceid;
dataP->type = type;
int64_t number = lua_tonumber(L,-1);
lwm2m_data_encode_int(number,dataP);
break;
case LUA_TSTRING:
dataP->id = resourceid;
dataP->value = strdup(lua_tolstring(L, -1, &dataP->length));
dataP->type = type;
if (dataP->value == NULL) {
// Manage memory allocation error
return COAP_500_INTERNAL_SERVER_ERROR ;
}
break;
case LUA_TTABLE:
if (type == LWM2M_TYPE_RESOURCE_INSTANCE)
return COAP_500_INTERNAL_SERVER_ERROR ;
// First iteration to get the number of resource instance
int size = 0;
lua_pushnil(L); // stack: ..., resourceValue, nil
while (lua_next(L, -2) != 0) { // stack: ...,resourceValue , key, value
if (lua_isnumber(L, -2)) {
size++;
}
// Removes 'value'; keeps 'key' for next iteration
lua_pop(L, 1); // stack: ...,resourceValue , key
}
// Second iteration to convert value to data
lwm2m_data_t * subdataP = lwm2m_data_new(size);
if (size > 0) {
lua_pushnil(L); // stack: ..., resourceValue, nil
int i = 0;
while (lua_next(L, -2) != 0) { // stack: ...,resourceValue , key, value
if (lua_isnumber(L, -2)) {
int err = prv_luaToResourceData(L, lua_tonumber(L, -2),
&subdataP[i], LWM2M_TYPE_RESOURCE_INSTANCE);
i++;
if (err) {
lua_pop(L, 2);
return err;
}
}
// Removes 'value'; keeps 'key' for next iteration
lua_pop(L, 1); // stack: ...,resourceValue , key
}
}
// Update Data struct
dataP->id = resourceid;
dataP->type = LWM2M_TYPE_MULTIPLE_RESOURCE;
dataP->value = (uint8_t *) subdataP;
dataP->length = size;
break;
default:
// Other type is not managed for now.
return COAP_501_NOT_IMPLEMENTED ;
break;
}
return COAP_NO_ERROR ;
}
static bool prv_convertValue(_record_t * recordP,
lwm2m_data_t * targetP)
{
switch (recordP->type)
{
case _TYPE_FALSE:
lwm2m_data_encode_bool(false, targetP);
break;
case _TYPE_TRUE:
lwm2m_data_encode_bool(true, targetP);
break;
case _TYPE_FLOAT:
{
size_t i;
i = 0;
while (i < recordP->valueLen
&& recordP->value[i] != '.')
{
i++;
}
if (i == recordP->valueLen)
{
int64_t value;
if ( 1 != utils_textToInt(recordP->value,
recordP->valueLen,
&value))
{
return false;
}
lwm2m_data_encode_int(value, targetP);
}
else
{
double value;
if ( 1 != utils_textToFloat(recordP->value,
recordP->valueLen,
&value))
{
return false;
}
lwm2m_data_encode_float(value, targetP);
}
}
break;
case _TYPE_STRING:
lwm2m_data_encode_opaque(recordP->value, recordP->valueLen, targetP);
targetP->type = LWM2M_TYPE_STRING;
break;
case _TYPE_UNSET:
default:
return false;
}
return true;
}
