static smcp_status_t
delete_response_handler(
int statuscode,
void* context
) {
if (statuscode >= 0) {
char* content = (char*)smcp_inbound_get_content_ptr();
coap_size_t content_length = smcp_inbound_get_content_len();
if(content_length>(smcp_inbound_get_packet_length()-4)) {
fprintf(stderr, "INTERNAL ERROR: CONTENT_LENGTH LARGER THAN PACKET_LENGTH-4! (content_length=%u, packet_length=%u)\n",content_length,smcp_inbound_get_packet_length());
gRet = ERRORCODE_UNKNOWN;
goto bail;
}
if (delete_show_headers) {
coap_dump_header(
stdout,
NULL,
smcp_inbound_get_packet(),
smcp_inbound_get_packet_length()
);
}
if(!coap_verify_packet((void*)smcp_inbound_get_packet(), smcp_inbound_get_packet_length())) {
fprintf(stderr, "INTERNAL ERROR: CALLBACK GIVEN INVALID PACKET!\n");
gRet = ERRORCODE_UNKNOWN;
goto bail;
}
if (statuscode != COAP_RESULT_202_DELETED) {
fprintf(stderr, "delete: Result code = %d (%s)\n", statuscode,
(statuscode < 0) ? smcp_status_to_cstr(
statuscode) : coap_code_to_cstr(statuscode));
}
if(content && content_length) {
char contentBuffer[500];
content_length =
((content_length > sizeof(contentBuffer) -
2) ? sizeof(contentBuffer) - 2 : content_length);
memcpy(contentBuffer, content, content_length);
contentBuffer[content_length] = 0;
if(content_length && (contentBuffer[content_length - 1] == '\n'))
contentBuffer[--content_length] = 0;
printf("%s\n", contentBuffer);
}
}
bail:
if (gRet == ERRORCODE_INPROGRESS) {
gRet = 0;
}
return SMCP_STATUS_OK;
}
static smcp_status_t
list_response_handler(
int statuscode,
void* context
) {
// smcp_t const self = smcp_get_current_instance();
const char* content = smcp_inbound_get_content_ptr();
printf(" *** GOT LIST RESPONSE!!! ***\n");
printf(" * RESULT CODE = %d (%s)\n", statuscode,
(statuscode>0)?coap_code_to_cstr(statuscode):smcp_status_to_cstr(statuscode));
if(content) {
printf(" * CONTENT = \"%s\"\n", content);
}
return SMCP_STATUS_OK;
}
static smcp_status_t
pair_response_handler(
int statuscode,
void* context
) {
// smcp_t const self = smcp_get_current_instance();
char* content = (char*)smcp_inbound_get_content_ptr();
coap_size_t content_length = smcp_inbound_get_content_len();
if((statuscode >= COAP_RESULT_100) && show_headers) {
fprintf(stdout, "\n");
coap_dump_header(
stdout,
"NULL",
smcp_inbound_get_packet(),
0
);
}
if(((statuscode < COAP_RESULT_200) ||
(statuscode >= COAP_RESULT_300)) &&
(statuscode != SMCP_STATUS_TRANSACTION_INVALIDATED))
fprintf(stderr, "pair: Result code = %d (%s)\n", statuscode,
(statuscode < 0) ? smcp_status_to_cstr(
statuscode) : coap_code_to_cstr(statuscode));
if(content &&
content_length) {
char contentBuffer[500];
content_length =
((content_length > sizeof(contentBuffer) -
2) ? sizeof(contentBuffer) - 2 : content_length);
memcpy(contentBuffer, content, content_length);
contentBuffer[content_length] = 0;
if(content_length && (contentBuffer[content_length - 1] == '\n'))
contentBuffer[--content_length] = 0;
printf("%s\n", contentBuffer);
}
if(gRet == ERRORCODE_INPROGRESS)
gRet = ERRORCODE_OK;
free(context);
return SMCP_STATUS_OK;
}
static smcp_status_t
request_handler(void* context) {
smcp_status_t ret = SMCP_STATUS_OK;
char* content = (char*)smcp_inbound_get_content_ptr();
size_t content_length = smcp_inbound_get_content_len();
char *path = NULL;
FILE * pFile;
path = smcp_inbound_get_path(NULL,0); // path must be free()'d after this!
//require_action_string(path && path[0], (free((void*)path),ret = SMCP_STATUS_INVALID_ARGUMENT));
if(smcp_inbound_get_code() != COAP_METHOD_POST) {
return SMCP_STATUS_NOT_IMPLEMENTED;
}
// Skip to the URI path option
while(smcp_inbound_peek_option(NULL, NULL) != COAP_OPTION_URI_PATH)
if(smcp_inbound_next_option(NULL, NULL) == COAP_OPTION_INVALID)
break;
smcp_outbound_begin_response(COAP_RESULT_205_CONTENT);
smcp_outbound_add_option_uint(
COAP_OPTION_CONTENT_TYPE,
COAP_CONTENT_TYPE_TEXT_PLAIN);
if(content && content_length) {
// if content exist then print and write on .txt file with "a" being append feature.
pFile = fopen ("data-collect.txt","a");
printf("%s", content);
if (pFile!=NULL) {
fputs (content,pFile);
fclose (pFile);
}
/* Only print a newline if the content doesn't already print one. */
if((content[content_length - 1] != '\n'))
printf("\n");
}
ret = smcp_outbound_send();
free((void*)path);
bail:
return ret;
}
static smcp_status_t
response_test_handler(int statuscode, void* context) {
test_data_s * const test_data = context;
smcp_t interface = smcp_get_current_instance();
bool has_observe_option = false;
smcp_status_t status = 0;
if(!test_data->finished) {
if (statuscode < 0) {
test_data->finished = true;
if (statuscode != SMCP_STATUS_TRANSACTION_INVALIDATED) {
test_data->error = statuscode;
}
} else {
const uint8_t* value;
coap_size_t value_len;
coap_option_key_t key;
test_data->msg_id = smcp_inbound_get_packet()->msg_id;
if (smcp_inbound_is_dupe()) {
test_data->inbound_dupe_packets++;
} else {
test_data->inbound_packets++;
}
while ((key=smcp_inbound_next_option(&value, &value_len))!=COAP_OPTION_INVALID) {
if (key == COAP_OPTION_BLOCK1) {
test_data->block1_option = 0;
test_data->has_block1_option = 1;
test_data->block1_option = coap_decode_uint32(value,(uint8_t)value_len);
if ( statuscode == COAP_RESULT_231_CONTINUE) {
smcp_transaction_new_msg_id(interface, test_data->transaction, smcp_get_next_msg_id(interface));
smcp_transaction_tickle(interface, test_data->transaction);
}
}
if (key == COAP_OPTION_BLOCK2) {
test_data->block2_option = 0;
test_data->has_block2_option = 1;
test_data->block2_option = coap_decode_uint32(value,(uint8_t)value_len);
if (!(test_data->block2_option & (1<<3))) {
test_data->finished = true;
}
}
if (key == COAP_OPTION_OBSERVE) {
if (test_data->inbound_packets > 2) {
test_data->finished = true;
}
has_observe_option = true;
printf("\tobs-response: \"%s\"\n", smcp_inbound_get_content_ptr());
}
}
if ( !has_observe_option
&& !test_data->has_block2_option
&& statuscode != COAP_RESULT_231_CONTINUE
) {
test_data->finished = true;
}
test_data->inbound_content_len += smcp_inbound_get_content_len();
test_data->inbound_code = (coap_code_t)statuscode;
if (test_data->has_block2_option) {
strncat(test_data->response, smcp_inbound_get_content_ptr(), smcp_inbound_get_content_len());
} else {
strncpy(test_data->response, smcp_inbound_get_content_ptr(), smcp_inbound_get_content_len());
}
}
}
return status;
}
smcp_status_t
smcp_variable_node_request_handler(
smcp_variable_node_t node
) {
// TODO: Make this function use less stack space!
smcp_method_t method = smcp_inbound_get_code();
smcp_status_t ret = SMCP_STATUS_NOT_FOUND;
SMCP_NON_RECURSIVE coap_content_type_t content_type;
SMCP_NON_RECURSIVE char* content_ptr;
SMCP_NON_RECURSIVE size_t content_len;
SMCP_NON_RECURSIVE char buffer[SMCP_VARIABLE_MAX_VALUE_LENGTH+1];
SMCP_NON_RECURSIVE coap_content_type_t reply_content_type;
uint8_t key_index = BAD_KEY_INDEX;
size_t value_len;
bool needs_prefix = true;
char* prefix_name = "";
content_type = smcp_inbound_get_content_type();
content_ptr = (char*)smcp_inbound_get_content_ptr();
content_len = smcp_inbound_get_content_len();
reply_content_type = SMCP_CONTENT_TYPE_APPLICATION_FORM_URLENCODED;
require(node, bail);
// Look up the key index.
if(smcp_inbound_peek_option(NULL,&value_len)==COAP_OPTION_URI_PATH) {
if(!value_len) {
needs_prefix = false;
smcp_inbound_next_option(NULL,NULL);
} else for(key_index=0;key_index<BAD_KEY_INDEX;key_index++) {
ret = node->func(node,SMCP_VAR_GET_KEY,key_index,buffer);
require_action(ret==0,bail,ret=SMCP_STATUS_NOT_FOUND);
if(smcp_inbound_option_strequal(COAP_OPTION_URI_PATH, buffer)) {
smcp_inbound_next_option(NULL,NULL);
break;
}
}
}
{
coap_option_key_t key;
const uint8_t* value;
while((key=smcp_inbound_next_option(&value, &value_len))!=COAP_OPTION_INVALID) {
require_action(key!=COAP_OPTION_URI_PATH,bail,ret=SMCP_STATUS_NOT_FOUND);
if(key==COAP_OPTION_URI_QUERY) {
if( method == COAP_METHOD_POST
&& value_len>=2
&& strhasprefix_const((const char*)value,"v=")
) {
DEBUG_PRINTF("variable-node: value is in the query.");
content_type = COAP_CONTENT_TYPE_TEXT_PLAIN;
content_ptr = (char*)value+2;
content_len = value_len-2;
}
// } else if(key==COAP_OPTION_ETAG) {
// } else if(key==COAP_OPTION_IF_MATCH) {
// } else if(key==COAP_OPTION_IF_NONE_MATCH) {
} else if(key==COAP_OPTION_ACCEPT) {
reply_content_type = 0;
if(value_len==1)
reply_content_type = value[0];
else {
// Unsupported type.
}
} else if(COAP_OPTION_IS_CRITICAL(key)) {
ret=SMCP_STATUS_BAD_OPTION;
assert_printf("Unrecognized option %d, \"%s\"",
key,
coap_option_key_to_cstr(key, false)
);
goto bail;
}
}
}
// TODO: Implement me!
if(method == COAP_METHOD_PUT)
method = COAP_METHOD_POST;
if(method == COAP_METHOD_POST) {
require_action(!smcp_inbound_is_dupe(),bail,ret=0);
require_action(
key_index!=BAD_KEY_INDEX,
bail,
ret=SMCP_STATUS_NOT_ALLOWED
);
if(content_type==SMCP_CONTENT_TYPE_APPLICATION_FORM_URLENCODED) {
char* key = NULL;
char* value = NULL;
content_len = 0;
while(
url_form_next_value(
(char**)&content_ptr,
&key,
&value
)
&& key
&& value
) {
if(strequal_const(key, "v")) {
content_ptr = value;
content_len = strlen(value);
break;
}
}
}
// Make sure our content is zero terminated.
((char*)content_ptr)[content_len] = 0;
ret = node->func(node,SMCP_VAR_SET_VALUE,key_index,(char*)content_ptr);
require_noerr(ret,bail);
ret = smcp_outbound_begin_response(COAP_RESULT_204_CHANGED);
require_noerr(ret,bail);
ret = smcp_outbound_send();
require_noerr(ret,bail);
} else if(method == COAP_METHOD_GET) {
if(key_index==BAD_KEY_INDEX) {
char* content_end_ptr;
ret = smcp_outbound_begin_response(COAP_RESULT_205_CONTENT);
require_noerr(ret,bail);
smcp_outbound_add_option_uint(COAP_OPTION_CONTENT_TYPE, COAP_CONTENT_TYPE_APPLICATION_LINK_FORMAT);
ret = smcp_observable_update(&node->observable, SMCP_OBSERVABLE_BROADCAST_KEY);
check_string(ret==0,smcp_status_to_cstr(ret));
content_ptr = smcp_outbound_get_content_ptr(&content_len);
content_end_ptr = content_ptr+content_len;
for(key_index=0;key_index<BAD_KEY_INDEX;key_index++) {
ret = node->func(node,SMCP_VAR_GET_KEY,key_index,buffer);
if(ret) break;
if(content_ptr+2>=content_end_ptr) {
// No more room for content.
break;
}
*content_ptr++ = '<';
if(needs_prefix) {
content_ptr += url_encode_cstr(content_ptr, prefix_name, (content_end_ptr-content_ptr)-1);
content_ptr = stpncpy(content_ptr,"/",MIN(1,(content_end_ptr-content_ptr)-1));
}
content_ptr += url_encode_cstr(content_ptr, buffer, (content_end_ptr-content_ptr)-1);
*content_ptr++ = '>';
ret = node->func(node,SMCP_VAR_GET_VALUE,key_index,buffer);
if(content_ptr+4>=content_end_ptr) {
// No more room for content.
break;
}
if(!ret) {
strcpy(content_ptr,";v=");
content_ptr += 3;
content_ptr += quoted_cstr(content_ptr, buffer, (content_end_ptr-content_ptr)-1);
}
ret = node->func(node,SMCP_VAR_GET_LF_TITLE,key_index,buffer);
if(content_ptr+8>=content_end_ptr) {
// No more room for content.
break;
}
if(!ret) {
strcpy(content_ptr,";title=");
content_ptr += 7;
content_ptr += quoted_cstr(content_ptr, buffer, (content_end_ptr-content_ptr)-1);
}
// Observation flag
if(0==node->func(node,SMCP_VAR_GET_OBSERVABLE,key_index,NULL)) {
content_ptr = stpncpy(content_ptr,";obs",MIN(4,(content_end_ptr-content_ptr)-1));
}
*content_ptr++ = ',';
}
ret = smcp_outbound_set_content_len(content_len-(content_end_ptr-content_ptr));
require_noerr(ret,bail);
ret = smcp_outbound_send();
} else {
size_t replyContentLength = 0;
char *replyContent;
ret = smcp_outbound_begin_response(COAP_RESULT_205_CONTENT);
require_noerr(ret,bail);
if(0==node->func(node,SMCP_VAR_GET_OBSERVABLE,key_index,buffer)) {
ret = smcp_observable_update(&node->observable, key_index);
check_string(ret==0,smcp_status_to_cstr(ret));
}
if(reply_content_type == SMCP_CONTENT_TYPE_APPLICATION_FORM_URLENCODED) {
uint32_t etag;
if(0==node->func(node,SMCP_VAR_GET_MAX_AGE,key_index,buffer)) {
#if HAVE_STRTOL
uint32_t max_age = strtol(buffer,NULL,0)&0xFFFFFF;
#else
uint32_t max_age = atoi(buffer)&0xFFFFFF;
#endif
smcp_outbound_add_option_uint(COAP_OPTION_MAX_AGE, max_age);
}
ret = node->func(node,SMCP_VAR_GET_VALUE,key_index,buffer);
require_noerr(ret,bail);
fasthash_start(0);
fasthash_feed((const uint8_t*)buffer,strlen(buffer));
etag = fasthash_finish_uint32();
smcp_outbound_add_option_uint(COAP_OPTION_CONTENT_TYPE, SMCP_CONTENT_TYPE_APPLICATION_FORM_URLENCODED);
smcp_outbound_add_option_uint(COAP_OPTION_ETAG, etag);
replyContent = smcp_outbound_get_content_ptr(&replyContentLength);
*replyContent++ = 'v';
*replyContent++ = '=';
replyContentLength -= 2;
replyContentLength = url_encode_cstr(
replyContent,
buffer,
replyContentLength
);
ret = smcp_outbound_set_content_len(replyContentLength+2);
} else {
ret = node->func(node,SMCP_VAR_GET_VALUE,key_index,buffer);
require_noerr(ret,bail);
ret = smcp_outbound_append_content(buffer, SMCP_CSTR_LEN);
}
require_noerr(ret,bail);
ret = smcp_outbound_send();
}
} else {
ret = smcp_default_request_handler(
(void*)node
);
check_string(ret == SMCP_STATUS_OK, smcp_status_to_cstr(ret));
}
bail:
check_string(ret == SMCP_STATUS_OK, smcp_status_to_cstr(ret));
return ret;
}
static smcp_status_t
request_handler_new_group_(
smcp_group_mgr_t self
) {
smcp_status_t ret = SMCP_STATUS_OK;
coap_content_type_t content_type;
coap_size_t content_len;
char* fqdn = NULL;
char* addr_cstr = NULL;
smcp_sockaddr_t saddr = { };
char* content_ptr = NULL;
char* key = NULL;
char* value = NULL;
smcp_group_t group = NULL;
char name_str[3] = { };
content_type = smcp_inbound_get_content_type();
content_ptr = (char*)smcp_inbound_get_content_ptr();
content_len = smcp_inbound_get_content_len();
switch (content_type) {
case COAP_CONTENT_TYPE_UNKNOWN:
case COAP_CONTENT_TYPE_TEXT_PLAIN:
case SMCP_CONTENT_TYPE_APPLICATION_FORM_URLENCODED:
content_len = 0;
while(
url_form_next_value(
(char**)&content_ptr,
&key,
&value
)
&& key
&& value
) {
if (strequal_const(key, names[I_FQDN])) {
fqdn = value;
DEBUG_PRINTF("new_group: fqdn=\"%s\"", value);
} else if (strequal_const(key, names[I_ADDR])) {
addr_cstr = value;
DEBUG_PRINTF("new_group: addr=\"%s\"", value);
}
}
break;
default:
return smcp_outbound_quick_response(HTTP_RESULT_CODE_UNSUPPORTED_MEDIA_TYPE, NULL);
break;
}
if (NULL == addr_cstr) {
require_action(NULL != fqdn, bail, ret = SMCP_STATUS_INVALID_ARGUMENT);
addr_cstr = fqdn;
} else if (NULL == fqdn) {
fqdn = addr_cstr;
}
smcp_plat_lookup_hostname(addr_cstr, &saddr, SMCP_LOOKUP_HOSTNAME_FLAG_DEFAULT);
group = smcp_group_mgr_new_group(
self,
fqdn,
&saddr.smcp_addr,
0
);
if (!group) {
return smcp_outbound_quick_response(COAP_RESULT_400_BAD_REQUEST, "(400) Failed to create group");
}
// Default to enabled.
smcp_group_set_enabled(group, true);
name_str[0] = get_hex_char(group->index >> 4);
name_str[1] = get_hex_char(group->index >> 0);
smcp_outbound_begin_response(COAP_RESULT_201_CREATED);
smcp_outbound_add_option(COAP_OPTION_LOCATION_PATH, name_str, SMCP_CSTR_LEN);
smcp_outbound_append_content(name_str, SMCP_CSTR_LEN);
smcp_outbound_send();
bail:
return ret;
}
smcp_status_t
smcp_curl_proxy_request_handler(
smcp_curl_proxy_node_t node
) {
smcp_status_t ret = SMCP_STATUS_NOT_ALLOWED;
smcp_curl_request_t request = NULL;
struct curl_slist *headerlist=NULL;
smcp_method_t method = smcp_inbound_get_code();
//require_action(method<=COAP_METHOD_DELETE,bail,ret = SMCP_STATUS_NOT_ALLOWED);
//require_action(COAP_OPTION_URI_PATH!=smcp_inbound_peek_option(NULL,NULL),bail,ret=SMCP_STATUS_NOT_FOUND);
node->interface = smcp_get_current_instance();
smcp_inbound_reset_next_option();
request = smcp_curl_request_create();
request->proxy_node = node;
require_action(request!=NULL,bail,ret = SMCP_STATUS_MALLOC_FAILURE);
switch(method) {
case COAP_METHOD_GET:
curl_easy_setopt(request->curl, CURLOPT_CUSTOMREQUEST, "GET");
break;
case COAP_METHOD_PUT:
curl_easy_setopt(request->curl, CURLOPT_PUT, 1L);
break;
case COAP_METHOD_POST:
curl_easy_setopt(request->curl, CURLOPT_POST, 1L);
break;
case COAP_METHOD_DELETE:
curl_easy_setopt(request->curl, CURLOPT_CUSTOMREQUEST, "DELETE");
break;
default:
ret = SMCP_STATUS_NOT_ALLOWED;
break;
}
{
coap_option_key_t key;
const uint8_t* value;
coap_size_t value_len;
while((key=smcp_inbound_next_option(&value, &value_len))!=COAP_OPTION_INVALID) {
if(key==COAP_OPTION_PROXY_URI) {
char uri[value_len+1];
memcpy(uri,value,value_len);
uri[value_len] = 0;
curl_easy_setopt(request->curl, CURLOPT_URL, uri);
assert_printf("CuRL URL: \"%s\"",uri);
ret = 0;
} else if(key==COAP_OPTION_URI_HOST) {
} else if(key==COAP_OPTION_URI_PORT) {
} else if(key==COAP_OPTION_URI_PATH) {
} else if(key==COAP_OPTION_URI_QUERY) {
} else if(key==COAP_OPTION_CONTENT_TYPE || key==COAP_OPTION_ACCEPT) {
const char* option_name = coap_option_key_to_cstr(key, false);
const char* value_string = coap_content_type_to_cstr(value[1]);
char header[strlen(option_name)+strlen(value_string)+3];
strcpy(header,option_name);
strcat(header,": ");
strcat(header,value_string);
headerlist = curl_slist_append(headerlist, header);
assert_printf("CuRL HEADER: \"%s\"",header);
} else {
if(coap_option_value_is_string(key)) {
const char* option_name = coap_option_key_to_cstr(key, false);
char header[strlen(option_name)+value_len+3];
strcpy(header,option_name);
strcat(header,": ");
strncat(header,(const char*)value,value_len);
assert_printf("CuRL HEADER: \"%s\"",header);
headerlist = curl_slist_append(headerlist, header);
}
}
}
}
require_noerr(ret,bail);
if(smcp_inbound_get_content_len()) {
coap_size_t len = smcp_inbound_get_content_len();
request->output_content = calloc(1,len+1);
request->output_content_len = len;
memcpy(request->output_content,smcp_inbound_get_content_ptr(),len);
curl_easy_setopt(request->curl, CURLOPT_READFUNCTION, ReadMemoryCallback);
curl_easy_setopt(request->curl, CURLOPT_READDATA, (void *)request);
}
curl_easy_setopt(request->curl, CURLOPT_USERAGENT, "smcp-curl-proxy/1.0");
curl_easy_setopt(request->curl, CURLOPT_HTTPHEADER, headerlist),headerlist=NULL;
curl_easy_setopt(request->curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(request->curl, CURLOPT_WRITEDATA, (void *)request);
ret = smcp_start_async_response(&request->async_response,0);
require_noerr(ret,bail);
if(node->curl_multi_handle)
curl_multi_add_handle(node->curl_multi_handle, request->curl);
else
curl_easy_perform(request->curl);
bail:
if(headerlist)
curl_slist_free_all(headerlist);
if(ret && request)
smcp_curl_request_release(request);
return ret;
}
static smcp_status_t
get_response_handler(int statuscode, void* context) {
ThingMLCOAPContext * thingml_context = (ThingMLCOAPContext *) context;
const char* content = (const char*)smcp_inbound_get_content_ptr();
coap_size_t content_length = smcp_inbound_get_content_len();
if(statuscode>=0) {
if(content_length>(smcp_inbound_get_packet_length()-4)) {
fprintf(stderr, "INTERNAL ERROR: CONTENT_LENGTH LARGER THAN PACKET_LENGTH-4! (content_length=%u, packet_length=%u)\n",content_length,smcp_inbound_get_packet_length());
gRet = ERRORCODE_UNKNOWN;
thingml_context->fn_onerror_callback(thingml_context->thing_instance, gRet);
goto bail;
}
if((statuscode >= 0) && get_show_headers) {
if(next_len != ((coap_size_t)(-1)))
fprintf(stdout, "\n\n");
coap_dump_header(
stdout,
NULL,
smcp_inbound_get_packet(),
smcp_inbound_get_packet_length()
);
}
if(!coap_verify_packet((void*)smcp_inbound_get_packet(), smcp_inbound_get_packet_length())) {
fprintf(stderr, "INTERNAL ERROR: CALLBACK GIVEN INVALID PACKET!\n");
gRet = ERRORCODE_UNKNOWN;
thingml_context->fn_onerror_callback(thingml_context->thing_instance, gRet);
goto bail;
}
}
if(statuscode == SMCP_STATUS_TRANSACTION_INVALIDATED) {
gRet = 0;
}
if(observe_ignore_first) {
observe_ignore_first = false;
goto bail;
}
if( ((statuscode < COAP_RESULT_200) ||(statuscode >= COAP_RESULT_400))
&& (statuscode != SMCP_STATUS_TRANSACTION_INVALIDATED)
&& (statuscode != HTTP_TO_COAP_CODE(HTTP_RESULT_CODE_PARTIAL_CONTENT))
) {
if(get_observe && statuscode == SMCP_STATUS_TIMEOUT) {
gRet = 0;
} else {
gRet = (statuscode == SMCP_STATUS_TIMEOUT)?ERRORCODE_TIMEOUT:ERRORCODE_COAP_ERROR;
fprintf(stderr, "get: Result code = %d (%s)\n", statuscode,
(statuscode < 0) ? smcp_status_to_cstr(
statuscode) : coap_code_to_cstr(statuscode));
thingml_context->fn_onerror_callback(thingml_context->thing_instance, gRet);
}
}
if((statuscode>0) && content && content_length) {
coap_option_key_t key;
const uint8_t* value;
coap_size_t value_len;
bool last_block = true;
int32_t observe_value = -1;
while((key=smcp_inbound_next_option(&value, &value_len))!=COAP_OPTION_INVALID) {
if(key == COAP_OPTION_BLOCK2) {
last_block = !(value[value_len-1]&(1<<3));
} else if(key == COAP_OPTION_OBSERVE) {
if(value_len)
observe_value = value[0];
else observe_value = 0;
}
}
thingml_context->fn_onmsgrcv_callback(thingml_context->thing_instance, content, content_length);
last_observe_value = observe_value;
}
if(observe_once) {
gRet = 0;
goto bail;
}
bail:
return SMCP_STATUS_OK;
}
