int vfs_dir_read_pass(struct vfs_inode_ptr *ptr,
struct vfs_inode_ptr *save_ptr,
void *data, uint32_t len,
bool *eof) {
uint32_t rlen;
int ret;
if (ptr->offt + len > OBJECT_MAX_SIZE) {
ptr->object.chunk++;
ptr->offt = 0;
}
memcpy(save_ptr, ptr, sizeof(*ptr));
if (!data)
return 0;
if ((ret = object_read(ptr->object, ptr->offt, data,
len, &rlen)) != SUCCESS) {
if (ret != NOT_FOUND)
warning("Read error on inode %016" PRIx64, ptr->object.index);
return -EFAULT;
}
if (rlen < len) {
*eof = true;
return 0;
}
ptr->offt += rlen;
return 0;
}
void object_reset(OBJECT*target)
{
OBJECT obj;
char *line;
OBJECTFILE file;
int rc, l, k;
if (target->name == NULL || target->_class == NULL) return;
*(target->value) = '\0';
for (k = 0; k < nfiles; k++)
{
file = object_fopen(filenames[k], "r");
if (file.file != NULL)
{
while ((line = object_read(file)) != NULL)
{
rc = object_lineparse(line, &obj);
if (rc < 2)
{
if (!strcmp(target->_class, obj._class) && !strcmp(target->name, obj.name))
{
l = strlen(target->value) + strlen(obj.value) + 1;
target->value = (char*) realloc(target->value, l);
strcat(target->value, obj.value);
}
}
free(obj.name);
free(obj._class);
free(obj.value);
}
object_fclose(file);
}
}
}
coap_status_t handle_dm_request(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP,
uint8_t * fromAddr,
size_t fromAddrLen,
coap_packet_t * message,
coap_packet_t * response)
{
coap_status_t result;
switch (message->code)
{
case COAP_GET:
{
char * buffer = NULL;
int length = 0;
result = object_read(contextP, uriP, &buffer, &length);
if (result == COAP_205_CONTENT)
{
if (IS_OPTION(message, COAP_OPTION_OBSERVE))
{
result = handle_observe_request(contextP, uriP, fromAddr, fromAddrLen, message, response);
}
if (result == COAP_205_CONTENT)
{
coap_set_payload(response, buffer, length);
// lwm2m_handle_packet will free buffer
}
}
}
break;
case COAP_POST:
{
result = object_create_execute(contextP, uriP, (char *)message->payload, message->payload_len);
}
break;
case COAP_PUT:
{
result = object_write(contextP, uriP, (char *)message->payload, message->payload_len);
}
break;
case COAP_DELETE:
{
result = object_delete(contextP, uriP);
}
break;
default:
result = BAD_REQUEST_4_00;
break;
}
return result;
}
void object_compilefilesubset(const char *filename, int first, int last)
{
OBJECT obj;
char *line;
OBJECTFILE file;
int rc, i, l, n;
file = object_fopen(filename, "r");
n=0;
if (file.file != NULL)
{
while ((line = object_read(file)) != NULL )
{
rc = object_lineparse(line, &obj);
if (rc < 2 && n>=first)
{
for (i = 0; i < nobject; i++)
{
if (!strcmp(object[i]._class, obj._class) && !strcmp(object[i].name, obj.name)) break;
}
if (i == nobject)
{
nobject++;
if (mobject < nobject) mobject += 100;
object = (OBJECT*) realloc(object, mobject*sizeof(OBJECT));
object[i].name = strdup(obj.name);
object[i]._class = strdup(obj._class);
object[i].value = strdup(obj.value);
object[i].valueptr = NULL;;
}
else
{
l = strlen(object[i].value) + strlen(obj.value) + 1;
object[i].value = (char*) realloc(object[i].value, l);
strcat(object[i].value, obj.value);
}
}
free(obj.name);
free(obj._class);
free(obj.value);
if ( ++n > last ) break;
}
object_fclose(file);
}
for (i = 0; i < nobject; i++) object_compilevalue(object + i);
}
OBJECT *object_find1(char *name, char *type)
{
OBJECTFILE file;
int rc, nfound, l, k;
OBJECT *object = NULL;
char *line, *value;
if (object == NULL) object = (OBJECT*) malloc(sizeof(OBJECT));
value = (char*) malloc(1);
*value = 0x0;
nfound = 0;
for (k = 0; k < nfiles; k++)
{
file = object_fopen(filenames[k], "r");
while ((line = object_read(file)) != NULL)
{
rc = object_lineparse(line, object);
if (rc < 2 && (strcmp(object->_class, type) == 0) && (strcmp(object->name, name) == 0))
{
nfound++;
l = strlen(value) + 1;
if (object->value != NULL)
{
l += strlen(object->value);
value = (char*) realloc(value, l);
strcat(value, object->value);
}
}
free(object->name);
free(object->_class);
free(object->value);
}
object_fclose(file);
}
if (nfound > 0)
{
object->name = strdup(name);
object->_class = strdup(type);
object->value = strdup(value);
return object;
}
error_action("Unable to locate object ", name, "in data files", ERROR_IN("object_find1", ABORT));
if(object) free(object);
return NULL;
}
void ICACHE_FLASH_ATTR
lwm2m_resource_value_changed(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP)
{
int result;
obs_list_t * listP;
lwm2m_watcher_t * watcherP;
listP = prv_getObservedList(contextP, uriP);
while (listP != NULL)
{
obs_list_t * targetP;
uint8_t * buffer = NULL;
size_t length = 0;
lwm2m_media_type_t format;
format = LWM2M_CONTENT_TEXT;
result = object_read(contextP, &listP->item->uri, &format, &buffer, &length);
if (result == COAP_205_CONTENT)
{
coap_packet_t message[1];
coap_init_message(message, COAP_TYPE_NON, COAP_205_CONTENT, 0);
coap_set_header_content_type(message, format);
coap_set_payload(message, buffer, length);
for (watcherP = listP->item->watcherList ; watcherP != NULL ; watcherP = watcherP->next)
{
watcherP->lastMid = contextP->nextMID++;
message->mid = watcherP->lastMid;
coap_set_header_token(message, watcherP->token, watcherP->tokenLen);
coap_set_header_observe(message, watcherP->counter++);
(void)message_send(contextP, message, watcherP->server->sessionH);
}
}
targetP = listP;
listP = listP->next;
lwm2m_free(targetP);
}
}
int vfs_io_perform(struct vfs_inode *node, enum vfs_io_type type, char *buf,
uint64_t size, off_t offset) {
struct volume_object object;
uint64_t chunk;
uint32_t nlen, offt;
int ret;
object.index = node->data.ino;
while (size) {
chunk = offset >> OBJECT_MAX_SIZE_LOG2;
offt = offset & ((1 << OBJECT_MAX_SIZE_LOG2) - 1);
nlen = min(OBJECT_MAX_SIZE - offt, size);
object.chunk = chunk;
switch (type) {
case VFS_IO_READ:
if ((ret = object_read(object, offt, buf, nlen, NULL)) != SUCCESS) {
if (ret == NOT_FOUND) {
memset(buf, 0, nlen);
} else {
warning("Object read error on %016" PRIx64 ":%u: %d",
node->data.ino, offt, ret);
return -EFAULT;
}
}
break;
case VFS_IO_WRITE:
if ((ret = object_write(object, offt, buf, nlen)) != SUCCESS) {
warning("Object write error on %016" PRIx64 ":%u: %d",
node->data.ino, offt, ret);
return -EFAULT;
}
break;
}
size -= nlen;
offset += nlen;
buf += nlen;
}
return 0;
}
void lwm2m_resource_value_changed(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP)
{
int result;
obs_list_t * listP;
lwm2m_watcher_t * watcherP;
listP = prv_getObservedList(contextP, uriP);
while (listP != NULL)
{
obs_list_t * targetP;
char * buffer = NULL;
int length = 0;
result = object_read(contextP, &listP->item->uri, &buffer, &length);
if (result == COAP_205_CONTENT)
{
coap_packet_t message[1];
coap_init_message(message, COAP_TYPE_ACK, COAP_204_CHANGED, 0);
coap_set_payload(message, buffer, length);
for (watcherP = listP->item->watcherList ; watcherP != NULL ; watcherP = watcherP->next)
{
watcherP->lastMid = contextP->nextMID++;
message->mid = watcherP->lastMid;
coap_set_header_token(message, watcherP->token, watcherP->tokenLen);
coap_set_header_observe(message, watcherP->counter++);
(void)message_send(contextP, message, watcherP->server->addr, watcherP->server->addrLen);
}
}
targetP = listP;
listP = listP->next;
lwm2m_free(targetP);
}
}
void observe_step(lwm2m_context_t * contextP,
time_t currentTime,
time_t * timeoutP)
{
lwm2m_observed_t * targetP;
for (targetP = contextP->observedList ; targetP != NULL ; targetP = targetP->next)
{
lwm2m_watcher_t * watcherP;
uint8_t * buffer = NULL;
size_t length = 0;
lwm2m_data_t * dataP = NULL;
int size = 0;
double floatValue = 0;
int64_t integerValue = 0;
bool storeValue = false;
lwm2m_media_type_t format = LWM2M_CONTENT_TEXT;
coap_packet_t message[1];
time_t interval;
if (LWM2M_URI_IS_SET_RESOURCE(&targetP->uri))
{
if (COAP_205_CONTENT != object_readData(contextP, &targetP->uri, &size, &dataP)) continue;
switch (dataP->type)
{
case LWM2M_TYPE_INTEGER:
if (1 != lwm2m_data_decode_int(dataP, &integerValue)) continue;
storeValue = true;
break;
case LWM2M_TYPE_FLOAT:
if (1 != lwm2m_data_decode_float(dataP, &floatValue)) continue;
storeValue = true;
break;
default:
break;
}
}
for (watcherP = targetP->watcherList ; watcherP != NULL ; watcherP = watcherP->next)
{
if (watcherP->active == true)
{
bool notify = false;
if (watcherP->update == true)
{
// value changed, should we notify the server ?
if (watcherP->parameters == NULL || watcherP->parameters->toSet == 0)
{
// no conditions
notify = true;
LOG("observation_step(/%d/%d/%d) notify[1] = TRUE\n", targetP->uri.objectId, targetP->uri.instanceId, targetP->uri.resourceId);
}
if (notify == false
&& watcherP->parameters != NULL
&& (watcherP->parameters->toSet & ATTR_FLAG_NUMERIC) != 0)
{
if ((watcherP->parameters->toSet & LWM2M_ATTR_FLAG_LESS_THAN) != 0)
{
// Did we cross the lower treshold ?
switch (dataP->type)
{
case LWM2M_TYPE_INTEGER:
if ((integerValue <= watcherP->parameters->lessThan
&& watcherP->lastValue.asInteger > watcherP->parameters->lessThan)
|| (integerValue >= watcherP->parameters->lessThan
&& watcherP->lastValue.asInteger < watcherP->parameters->lessThan))
{
notify = true;
}
break;
case LWM2M_TYPE_FLOAT:
if ((floatValue <= watcherP->parameters->lessThan
&& watcherP->lastValue.asFloat > watcherP->parameters->lessThan)
|| (floatValue >= watcherP->parameters->lessThan
&& watcherP->lastValue.asFloat < watcherP->parameters->lessThan))
{
notify = true;
}
break;
default:
break;
}
LOG("observation_step(/%d/%d/%d) notify[2] = %s\n", targetP->uri.objectId, targetP->uri.instanceId, targetP->uri.resourceId, notify ? "TRUE" : "FALSE");
}
if ((watcherP->parameters->toSet & LWM2M_ATTR_FLAG_GREATER_THAN) != 0)
{
// Did we cross the upper treshold ?
switch (dataP->type)
{
case LWM2M_TYPE_INTEGER:
if ((integerValue <= watcherP->parameters->greaterThan
&& watcherP->lastValue.asInteger > watcherP->parameters->greaterThan)
|| (integerValue >= watcherP->parameters->greaterThan
&& watcherP->lastValue.asInteger < watcherP->parameters->greaterThan))
{
notify = true;
}
break;
case LWM2M_TYPE_FLOAT:
if ((floatValue <= watcherP->parameters->greaterThan
&& watcherP->lastValue.asFloat > watcherP->parameters->greaterThan)
|| (floatValue >= watcherP->parameters->greaterThan
&& watcherP->lastValue.asFloat < watcherP->parameters->greaterThan))
{
notify = true;
}
break;
default:
break;
}
LOG("observation_step(/%d/%d/%d) notify[3] = %s\n", targetP->uri.objectId, targetP->uri.instanceId, targetP->uri.resourceId, notify ? "TRUE" : "FALSE");
}
if ((watcherP->parameters->toSet & LWM2M_ATTR_FLAG_STEP) != 0)
{
switch (dataP->type)
{
case LWM2M_TYPE_INTEGER:
{
int64_t diff;
diff = integerValue - watcherP->lastValue.asInteger;
if ((diff < 0 && (0 - diff) >= watcherP->parameters->step)
|| (diff >= 0 && diff >= watcherP->parameters->step))
{
notify = true;
}
}
break;
case LWM2M_TYPE_FLOAT:
{
double diff;
diff = floatValue - watcherP->lastValue.asFloat;
if ((diff < 0 && (0 - diff) >= watcherP->parameters->step)
|| (diff >= 0 && diff >= watcherP->parameters->step))
{
notify = true;
}
}
break;
default:
break;
}
LOG("observation_step(/%d/%d/%d) notify[4] = %s\n", targetP->uri.objectId, targetP->uri.instanceId, targetP->uri.resourceId, notify? "TRUE" : "FALSE");
}
}
if (watcherP->parameters != NULL
&& (watcherP->parameters->toSet & LWM2M_ATTR_FLAG_MIN_PERIOD) != 0)
{
if (watcherP->lastTime + watcherP->parameters->minPeriod > currentTime)
{
// Minimum Period did not elapse yet
interval = watcherP->lastTime + watcherP->parameters->minPeriod - currentTime;
if (*timeoutP > interval) *timeoutP = interval;
notify = false;
}
else
{
notify = true;
}
LOG("observation_step(/%d/%d/%d) notify[5] = %s\n", targetP->uri.objectId, targetP->uri.instanceId, targetP->uri.resourceId, notify ? "TRUE" : "FALSE");
}
}
// Is the Maximum Period reached ?
if (notify == false
&& watcherP->parameters != NULL
&& (watcherP->parameters->toSet & LWM2M_ATTR_FLAG_MAX_PERIOD) != 0)
{
if (watcherP->lastTime + watcherP->parameters->maxPeriod <= currentTime)
{
notify = true;
}
LOG("observation_step(/%d/%d/%d) notify[6] = %s\n", targetP->uri.objectId, targetP->uri.instanceId, targetP->uri.resourceId, notify ? "TRUE" : "FALSE");
}
if (notify == true)
{
if (buffer == NULL)
{
if (dataP != NULL)
{
length = lwm2m_data_serialize(&targetP->uri, size, dataP, &format, &buffer);
if (length == 0) break;
}
else
{
if (COAP_205_CONTENT != object_read(contextP, &targetP->uri, &format, &buffer, &length))
{
buffer = NULL;
break;
}
}
coap_init_message(message, COAP_TYPE_NON, COAP_205_CONTENT, 0);
coap_set_header_content_type(message, format);
coap_set_payload(message, buffer, length);
LOG("Observe Update[/%d/%d/%d]: %.*s\n", targetP->uri.objectId, targetP->uri.instanceId, targetP->uri.resourceId, length, buffer);
}
watcherP->lastTime = currentTime;
watcherP->lastMid = contextP->nextMID++;
message->mid = watcherP->lastMid;
coap_set_header_token(message, watcherP->token, watcherP->tokenLen);
coap_set_header_observe(message, watcherP->counter++);
(void)message_send(contextP, message, watcherP->server->sessionH);
watcherP->update = false;
}
// Store this value
if (notify == true && storeValue == true)
{
switch (dataP->type)
{
case LWM2M_TYPE_INTEGER:
watcherP->lastValue.asInteger = integerValue;
break;
case LWM2M_TYPE_FLOAT:
watcherP->lastValue.asFloat = floatValue;
break;
default:
break;
}
}
if (watcherP->parameters != NULL && (watcherP->parameters->toSet & LWM2M_ATTR_FLAG_MAX_PERIOD) != 0)
{
// update timers
interval = watcherP->lastTime + watcherP->parameters->maxPeriod - currentTime;
if (*timeoutP > interval) *timeoutP = interval;
}
}
}
if (dataP != NULL) lwm2m_data_free(size, dataP);
if (buffer != NULL) lwm2m_free(buffer);
}
}
uint8_t dm_handleRequest(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP,
lwm2m_server_t * serverP,
coap_packet_t * message,
coap_packet_t * response)
{
uint8_t result;
lwm2m_media_type_t format;
LOG_ARG("Code: %02X, server status: %s", message->code, STR_STATUS(serverP->status));
LOG_URI(uriP);
if (IS_OPTION(message, COAP_OPTION_CONTENT_TYPE))
{
format = utils_convertMediaType(message->content_type);
}
else
{
format = LWM2M_CONTENT_TLV;
}
if (uriP->objectId == LWM2M_SECURITY_OBJECT_ID)
{
return COAP_404_NOT_FOUND;
}
if (serverP->status != STATE_REGISTERED
&& serverP->status != STATE_REG_UPDATE_NEEDED
&& serverP->status != STATE_REG_FULL_UPDATE_NEEDED
&& serverP->status != STATE_REG_UPDATE_PENDING)
{
return COAP_IGNORE;
}
// TODO: check ACL
switch (message->code)
{
case COAP_GET:
{
uint8_t * buffer = NULL;
size_t length = 0;
int res;
if (IS_OPTION(message, COAP_OPTION_OBSERVE))
{
lwm2m_data_t * dataP = NULL;
int size = 0;
result = object_readData(contextP, uriP, &size, &dataP);
if (COAP_205_CONTENT == result)
{
result = observe_handleRequest(contextP, uriP, serverP, size, dataP, message, response);
if (COAP_205_CONTENT == result)
{
if (IS_OPTION(message, COAP_OPTION_ACCEPT))
{
format = utils_convertMediaType(message->accept[0]);
}
else
{
format = LWM2M_CONTENT_TLV;
}
res = lwm2m_data_serialize(uriP, size, dataP, &format, &buffer);
if (res < 0)
{
result = COAP_500_INTERNAL_SERVER_ERROR;
}
else
{
length = (size_t)res;
LOG_ARG("Observe Request[/%d/%d/%d]: %.*s\n", uriP->objectId, uriP->instanceId, uriP->resourceId, length, buffer);
}
}
lwm2m_data_free(size, dataP);
}
}
else if (IS_OPTION(message, COAP_OPTION_ACCEPT)
&& message->accept_num == 1
&& message->accept[0] == APPLICATION_LINK_FORMAT)
{
format = LWM2M_CONTENT_LINK;
result = object_discover(contextP, uriP, serverP, &buffer, &length);
}
else
{
if (IS_OPTION(message, COAP_OPTION_ACCEPT))
{
format = utils_convertMediaType(message->accept[0]);
}
result = object_read(contextP, uriP, &format, &buffer, &length);
}
if (COAP_205_CONTENT == result)
{
coap_set_header_content_type(response, format);
coap_set_payload(response, buffer, length);
// lwm2m_handle_packet will free buffer
}
else
{
lwm2m_free(buffer);
}
}
break;
case COAP_POST:
{
if (!LWM2M_URI_IS_SET_INSTANCE(uriP))
{
result = object_create(contextP, uriP, format, message->payload, message->payload_len);
if (result == COAP_201_CREATED)
{
//longest uri is /65535/65535 = 12 + 1 (null) chars
char location_path[13] = "";
//instanceId expected
if ((uriP->flag & LWM2M_URI_FLAG_INSTANCE_ID) == 0)
{
result = COAP_500_INTERNAL_SERVER_ERROR;
break;
}
if (sprintf(location_path, "/%d/%d", uriP->objectId, uriP->instanceId) < 0)
{
result = COAP_500_INTERNAL_SERVER_ERROR;
break;
}
coap_set_header_location_path(response, location_path);
lwm2m_update_registration(contextP, 0, true);
}
}
else if (!LWM2M_URI_IS_SET_RESOURCE(uriP))
{
result = object_write(contextP, uriP, format, message->payload, message->payload_len);
}
else
{
result = object_execute(contextP, uriP, message->payload, message->payload_len);
}
}
break;
case COAP_PUT:
{
if (IS_OPTION(message, COAP_OPTION_URI_QUERY))
{
lwm2m_attributes_t attr;
if (0 != prv_readAttributes(message->uri_query, &attr))
{
result = COAP_400_BAD_REQUEST;
}
else
{
result = observe_setParameters(contextP, uriP, serverP, &attr);
}
}
else if (LWM2M_URI_IS_SET_INSTANCE(uriP))
{
result = object_write(contextP, uriP, format, message->payload, message->payload_len);
}
else
{
result = COAP_400_BAD_REQUEST;
}
}
break;
case COAP_DELETE:
{
if (!LWM2M_URI_IS_SET_INSTANCE(uriP) || LWM2M_URI_IS_SET_RESOURCE(uriP))
{
result = COAP_400_BAD_REQUEST;
}
else
{
result = object_delete(contextP, uriP);
if (result == COAP_202_DELETED)
{
lwm2m_update_registration(contextP, 0, true);
}
}
}
break;
default:
result = COAP_400_BAD_REQUEST;
break;
}
return result;
}
void object_compileSectionedFile(char *filename, int section)
{
OBJECT obj, obj_delim;
char *line;
OBJECTFILE file;
int rc, i, l, sec;
obj.name = obj_delim.name = NULL;
file = object_fopen(filename, "r");
sec = -1;
if (file.file != NULL)
{
while ((line = object_read(file)) != NULL)
{
rc = object_lineparse(line, &obj);
if (rc < 2)
{
if (sec == -1)
{
obj_delim.name = strdup(obj.name);
obj_delim._class = strdup(obj._class);
}
if (!strcmp(obj_delim._class, obj._class) && !strcmp(obj_delim.name, obj.name)) sec++;
if (sec > section) break;
if (sec == section)
{
for (i = 0; i < nobject; i++)
{
if (!strcmp(object[i]._class, obj._class) && !strcmp(object[i].name, obj.name)) break;
}
if (i == nobject)
{
nobject++;
if (mobject < nobject) mobject += 100;
object = (OBJECT*) realloc(object, mobject*sizeof(OBJECT));
object[i].name = strdup(obj.name);
object[i]._class = strdup(obj._class);
object[i].value = strdup(obj.value);
object[i].valueptr = NULL;;
}
else
{
l = strlen(object[i].value) + strlen(obj.value) + 1;
object[i].value = (char*)realloc(object[i].value, l);
strcat(object[i].value, obj.value);
}
}
}
if (obj.name != NULL)
{
free(obj.name);
free(obj._class);
free(obj.value);
}
}
if (obj_delim.name != NULL)
{
free(obj_delim.name);
free(obj_delim._class);
}
object_fclose(file);
}
for (i = 0; i < nobject; i++) object_compilevalue(object + i);
}
coap_status_t handle_dm_request(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP,
void * fromSessionH,
coap_packet_t * message,
coap_packet_t * response)
{
coap_status_t result;
lwm2m_server_t * serverP = NULL;
lwm2m_media_type_t format;
#ifdef LWM2M_BOOTSTRAP
lwm2m_server_t * bsServerP = NULL;
#endif
format = prv_convertMediaType(message->content_type);
serverP = prv_findServer(contextP, fromSessionH);
if (NULL == serverP)
{
#ifdef LWM2M_BOOTSTRAP
bsServerP = utils_findBootstrapServer(contextP, fromSessionH);
if (NULL == bsServerP)
{
// No server found
return COAP_IGNORE;
}
#else
return COAP_IGNORE;
#endif
}
#ifdef LWM2M_BOOTSTRAP
if (contextP->bsState != BOOTSTRAP_PENDING)
{
if (NULL != bsServerP)
{
// server initiated bootstrap?
// currently not implemented.
return NOT_IMPLEMENTED_5_01;
}
if ( serverP->status != STATE_REGISTERED &&
serverP->status != STATE_REG_UPDATE_PENDING)
{
return COAP_IGNORE;
}
}
else
{
if (NULL != serverP)
{
// Request form management server during bootstrap.
return UNAUTHORIZED_4_01;
}
}
#endif
switch (message->code)
{
case COAP_GET:
{
uint8_t * buffer = NULL;
size_t length = 0;
result = object_read(contextP, uriP, &format, &buffer, &length);
if (COAP_205_CONTENT == result)
{
if (IS_OPTION(message, COAP_OPTION_OBSERVE))
{
result = handle_observe_request(contextP, uriP, serverP, message, response);
}
if (COAP_205_CONTENT == result)
{
coap_set_header_content_type(response, format);
coap_set_payload(response, buffer, length);
// lwm2m_handle_packet will free buffer
}
else
{
lwm2m_free(buffer);
}
}
}
break;
case COAP_POST:
{
#ifdef LWM2M_BOOTSTRAP
/* no POST during bootstrap */
if (contextP->bsState == BOOTSTRAP_PENDING) return METHOD_NOT_ALLOWED_4_05;
#endif
if (!LWM2M_URI_IS_SET_INSTANCE(uriP))
{
lwm2m_media_type_t format;
format = prv_convertMediaType(message->content_type);
result = object_create(contextP, uriP, format, message->payload, message->payload_len);
if (result == COAP_201_CREATED)
{
//longest uri is /65535/65535 = 12 + 1 (null) chars
char location_path[13] = "";
//instanceId expected
if ((uriP->flag & LWM2M_URI_FLAG_INSTANCE_ID) == 0)
{
result = COAP_500_INTERNAL_SERVER_ERROR;
break;
}
if (sprintf(location_path, "/%d/%d", uriP->objectId, uriP->instanceId) < 0)
{
result = COAP_500_INTERNAL_SERVER_ERROR;
break;
}
coap_set_header_location_path(response, location_path);
}
}
else if (!LWM2M_URI_IS_SET_RESOURCE(uriP))
{
if (object_isInstanceNew(contextP, uriP->objectId, uriP->instanceId))
{
result = object_create(contextP, uriP, format, message->payload, message->payload_len);
}
else
{
result = object_write(contextP, uriP, format, message->payload, message->payload_len);
}
}
else
{
result = object_execute(contextP, uriP, message->payload, message->payload_len);
}
}
break;
case COAP_PUT:
{
if (LWM2M_URI_IS_SET_INSTANCE(uriP))
{
#ifdef LWM2M_BOOTSTRAP
if (contextP->bsState == BOOTSTRAP_PENDING && object_isInstanceNew(contextP, uriP->objectId, uriP->instanceId))
{
result = object_create(contextP, uriP, format, message->payload, message->payload_len);
if (COAP_201_CREATED == result)
{
result = COAP_204_CHANGED;
}
}
else
#endif
{
result = object_write(contextP, uriP, format, message->payload, message->payload_len);
}
}
else
{
result = BAD_REQUEST_4_00;
}
}
break;
case COAP_DELETE:
{
if (LWM2M_URI_IS_SET_INSTANCE(uriP) && !LWM2M_URI_IS_SET_RESOURCE(uriP))
{
result = object_delete(contextP, uriP);
}
else
{
result = BAD_REQUEST_4_00;
}
}
break;
default:
result = BAD_REQUEST_4_00;
break;
}
return result;
}
