bool M2MReportHandler::parse_notification_attribute(char *&query,
M2MBase::BaseType type)
{
tr_debug("M2MReportHandler::parse_notification_attribute(Query %s, Base type %d)", query, (int)type);
bool success = false;
char* sep_pos = strchr(query, '&');
char* rest = query;
if( sep_pos != NULL ){
char query_options[5][20];
memset(query_options, 0, sizeof(query_options[0][0]) * 5 * 20);
uint8_t num_options = 0;
while( sep_pos != NULL && num_options < 5){
size_t len = (size_t)(sep_pos-rest);
if( len > 19 ){
len = 19;
}
memcpy(query_options[num_options], rest, len);
sep_pos++;
rest = sep_pos;
sep_pos = strchr(rest, '&');
num_options++;
}
if( num_options < 5 && strlen(rest) > 0){
size_t len = (size_t)strlen(rest);
if( len > 19 ){
len = 19;
}
memcpy(query_options[num_options++], rest, len);
}
float pmin = _pmin;
float pmax = _pmax;
float lt = _lt;
float gt = _gt;
float st = _st;
float high = _high_step;
float low = _low_step;
int attr = _attribute_state;
for (int option = 0; option < num_options; option++) {
if(set_notification_attribute(query_options[option],type)) {
success = true;
}
}
if(success) {
success = check_attribute_validity();
}
if(!success) {
_pmin = pmin;
_pmax = pmax;
_st = st;
_lt = lt;
_gt = gt;
_high_step = high;
_low_step = low;
_attribute_state = attr;
}
else {
set_under_observation(!(_attribute_state & M2MReportHandler::Cancel) == M2MReportHandler::Cancel);
}
}
else {
if(set_notification_attribute(query, type)) {
set_under_observation(!(_attribute_state & M2MReportHandler::Cancel) == M2MReportHandler::Cancel);
success = true;
}
}
return success;
}
sn_coap_hdr_s* M2MResource::handle_get_request(nsdl_s *nsdl,
sn_coap_hdr_s *received_coap_header,
M2MObservationHandler *observation_handler)
{
tr_debug("M2MResource::handle_get_request()");
sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CONTENT;
sn_coap_hdr_s * coap_response = NULL;
if(_has_multiple_instances) {
coap_response = sn_nsdl_build_response(nsdl,
received_coap_header,
msg_code);
if(received_coap_header) {
// process the GET if we have registered a callback for it
if ((operation() & SN_GRS_GET_ALLOWED) != 0) {
if(coap_response) {
uint16_t coap_content_type = 0;
bool content_type_present = false;
if(received_coap_header->content_type_ptr){
content_type_present = true;
coap_response->content_type_ptr = alloc_copy(received_coap_header->content_type_ptr,
received_coap_header->content_type_len);
if(coap_response->content_type_ptr) {
coap_response->content_type_len = received_coap_header->content_type_len;
for(uint8_t i = 0; i < coap_response->content_type_len; i++) {
coap_content_type = (coap_content_type << 8) +
(coap_response->content_type_ptr[i] & 0xFF);
}
}
}
if(!content_type_present &&
M2MBase::coap_content_type() == COAP_CONTENT_OMA_TLV_TYPE) {
coap_content_type = COAP_CONTENT_OMA_TLV_TYPE;
}
tr_debug("M2MResource::handle_get_request() - Request Content-Type %d", coap_content_type);
if (!coap_response->content_type_ptr) {
coap_response->content_type_ptr =
m2m::String::convert_integer_to_array(coap_content_type,
coap_response->content_type_len);
if (coap_response->content_type_ptr) {
set_coap_content_type(coap_content_type);
}
}
uint8_t *data = NULL;
uint32_t data_length = 0;
// fill in the CoAP response payload
if(COAP_CONTENT_OMA_TLV_TYPE == coap_content_type) {
M2MTLVSerializer *serializer = new M2MTLVSerializer();
if(serializer) {
data = serializer->serialize(this, data_length);
delete serializer;
}
} else {
msg_code = COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT; // Content format not supported
}
coap_response->payload_len = data_length;
coap_response->payload_ptr = data;
coap_response->options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
memset(coap_response->options_list_ptr, 0, sizeof(sn_coap_options_list_s));
coap_response->options_list_ptr->max_age_ptr =
m2m::String::convert_integer_to_array(max_age(),
coap_response->options_list_ptr->max_age_len);
if(received_coap_header->token_ptr) {
tr_debug("M2MResource::handle_get_request - Sets Observation Token to resource");
set_observation_token(received_coap_header->token_ptr,
received_coap_header->token_len);
}
if(received_coap_header->options_list_ptr) {
if(received_coap_header->options_list_ptr->observe) {
if (is_observable()) {
uint32_t number = 0;
uint8_t observe_option = 0;
if(received_coap_header->options_list_ptr->observe_ptr) {
observe_option = *received_coap_header->options_list_ptr->observe_ptr;
}
if(START_OBSERVATION == observe_option) {
tr_debug("M2MResource::handle_get_request - Starts Observation");
// If the observe length is 0 means register for observation.
if(received_coap_header->options_list_ptr->observe_len != 0) {
for(int i=0;i < received_coap_header->options_list_ptr->observe_len; i++) {
number = (*(received_coap_header->options_list_ptr->observe_ptr + i) & 0xff) <<
8*(received_coap_header->options_list_ptr->observe_len- 1 - i);
}
}
// If the observe value is 0 means register for observation.
if(number == 0) {
tr_debug("M2MResource::handle_get_request - Put Resource under Observation");
M2MResourceInstanceList::const_iterator it;
it = _resource_instance_list.begin();
for (; it!=_resource_instance_list.end(); it++ ) {
tr_debug("M2MResource::handle_get_request - set_resource_observer");
(*it)->set_resource_observer(this);
(*it)->add_observation_level(M2MBase::R_Attribute);
}
set_under_observation(true,observation_handler);
M2MBase::add_observation_level(M2MBase::R_Attribute);
coap_response->options_list_ptr->observe_ptr =
m2m::String::convert_integer_to_array(observation_number(),
coap_response->options_list_ptr->observe_len);
}
} else if (STOP_OBSERVATION == observe_option) {
tr_debug("M2MResource::handle_get_request - Stops Observation");
set_under_observation(false,NULL);
M2MBase::remove_observation_level(M2MBase::R_Attribute);
M2MResourceInstanceList::const_iterator it;
it = _resource_instance_list.begin();
for (; it!=_resource_instance_list.end(); it++ ) {
(*it)->set_resource_observer(NULL);
}
}
msg_code = COAP_MSG_CODE_RESPONSE_CONTENT;
}
else {
msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
}
}
}
}
} else {
tr_error("M2MResource::handle_get_request - Return COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED");
// Operation is not allowed.
msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
}
}
if(coap_response) {
coap_response->msg_code = msg_code;
}
} else {
coap_response = M2MResourceInstance::handle_get_request(nsdl,
received_coap_header,
observation_handler);
}
return coap_response;
}
bool M2MReportHandler::set_notification_attribute(char* option,
M2MBase::BaseType type)
{
tr_debug("M2MReportHandler::set_notification_attribute()");
bool success = false;
bool observation = true;
char attribute[20];
char value[20];
memset(&attribute, 0, 20);
memset(&value, 0, 20);
char* pos = strstr(option, EQUAL.c_str());
if( pos != NULL ){
memcpy(attribute, option, (size_t)(pos-option));
pos++;
memcpy(value, pos, 20 );
}else{
memcpy(attribute, option, (size_t)strlen(option) + 1);
}
if (strcmp(attribute, PMIN.c_str()) == 0) {
sscanf(value, "%f", &_pmin);
success = true;
_attribute_state |= M2MReportHandler::Pmin;
tr_debug("M2MReportHandler::set_notification_attribute %s to %f", attribute, _pmin);
}
else if(strcmp(attribute, PMAX.c_str()) == 0) {
sscanf(value, "%f", &_pmax);
success = true;
_attribute_state |= M2MReportHandler::Pmax;
tr_debug("M2MReportHandler::set_notification_attribute %s to %f", attribute, _pmax);
}
else if(strcmp(attribute, GT.c_str()) == 0 &&
M2MBase::Resource == type){
sscanf(value, "%f", &_gt);
success = true;
_attribute_state |= M2MReportHandler::Gt;
tr_debug("M2MReportHandler::set_notification_attribute %s to %f", attribute, _gt);
}
else if(strcmp(attribute, LT.c_str()) == 0 &&
M2MBase::Resource == type){
sscanf(value, "%f", &_lt);
success = true;
_attribute_state |= M2MReportHandler::Lt;
tr_debug("M2MReportHandler::set_notification_attribute %s to %f", attribute, _lt);
}
else if(strcmp(attribute, ST.c_str()) == 0 &&
M2MBase::Resource == type){
sscanf(value, "%f", &_st);
success = true;
_high_step = _current_value + _st;
_low_step = _current_value - _st;
_attribute_state |= M2MReportHandler::St;
tr_debug("M2MReportHandler::set_notification_attribute %s to %f", attribute, _st);
}
else if(strcmp(attribute, CANCEL.c_str()) == 0) {
observation = false;
success = true;
_attribute_state |= M2MReportHandler::Cancel;
}
if(success) {
tr_debug("M2MReportHandler::set_notification_attribute %s - set under observation", attribute);
set_under_observation(observation);
}
return success;
}
