static smcp_status_t
request_handler(void* context) {
/* This will respond to every GET request to `/hello-world' with
** "Hello world!". Everyone else gets a 4.04 Not Found. */
printf("Got a request!\n");
if(smcp_inbound_get_code() != COAP_METHOD_GET) {
return SMCP_STATUS_NOT_IMPLEMENTED;
}
while(smcp_inbound_peek_option(NULL, NULL) != COAP_OPTION_URI_PATH)
if(smcp_inbound_next_option(NULL, NULL) == COAP_OPTION_INVALID)
break;
if(smcp_inbound_option_strequal(COAP_OPTION_URI_PATH, "hello-world")) {
smcp_outbound_begin_response(COAP_RESULT_205_CONTENT);
smcp_outbound_add_option_uint(
COAP_OPTION_CONTENT_TYPE,
COAP_CONTENT_TYPE_TEXT_PLAIN
);
smcp_outbound_append_content("Hello world!", SMCP_CSTR_LEN);
return smcp_outbound_send();
}
return SMCP_STATUS_NOT_FOUND;
}
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
request_handler(void* context) {
/* This will respond to every GET request to `/hello-world' with
** "Hello world!". Everyone else gets a 4.04 Not Found. */
printf("Got a request!\n");
// Only handle GET requests for now. Returning SMCP_STATUS_NOT_IMPLEMENTED
// here without sending a response will cause us to automatically
// send a METHOD_NOT_IMPLEMENTED response.
if(smcp_inbound_get_code() != COAP_METHOD_GET) {
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;
// If our URI path matches what we are looking for...
if(smcp_inbound_option_strequal(COAP_OPTION_URI_PATH, "hello-world")) {
// Begin describing the response message. (2.05 CONTENT,
// in this case)
smcp_outbound_begin_response(COAP_RESULT_205_CONTENT);
// Add an option describing the content type as plaintext.
smcp_outbound_add_option_uint(
COAP_OPTION_CONTENT_TYPE,
COAP_CONTENT_TYPE_TEXT_PLAIN
);
// Set the content of our response to be "Hello world!".
smcp_outbound_append_content("Hello world!", SMCP_CSTR_LEN);
// Send the response we hae created, passing the return value
// to our caller.
return smcp_outbound_send();
}
return SMCP_STATUS_NOT_FOUND;
}
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;
}
smcp_status_t
smcp_group_mgr_request_handler(
smcp_group_mgr_t self
) {
smcp_status_t ret = 0;
const smcp_method_t method = smcp_inbound_get_code();
coap_option_key_t key;
const uint8_t* value;
coap_size_t value_len;
smcp_group_t group;
bool missing_trailing_slash = false;
if (smcp_inbound_next_option(&value, &value_len) != COAP_OPTION_URI_PATH) {
missing_trailing_slash = true;
}
if (value_len == 0) {
// listing groups
if (method == COAP_METHOD_GET) {
if (missing_trailing_slash) {
return smcp_outbound_quick_response(COAP_RESULT_400_BAD_REQUEST, "(400) Needs trailing slash");
}
return request_handler_get_listing_(self);
} else if (method == COAP_METHOD_POST) {
return request_handler_new_group_(self);
} else {
ret = SMCP_STATUS_NOT_ALLOWED;
goto bail;
}
} else if (value_len == 2) {
// Query on a specific group.
const char str[3] = {value[0], value[1], 0};
int i;
errno = 0;
#if HAVE_STRTOL
i = strtol(str, NULL, 16);
#else
i = atoi(str); // TODO: This isn't base16!
#endif
if (errno) {
ret = SMCP_STATUS_NOT_FOUND;
goto bail;
}
group = &self->group_table[i];
key = smcp_inbound_peek_option(&value, &value_len);
if ( (i < 0)
|| (i >= SMCP_CONF_MAX_GROUPS)
|| (!group->in_use)
) {
ret = SMCP_STATUS_NOT_FOUND;
goto bail;
}
if (key != COAP_OPTION_URI_PATH) {
value_len = 0;
}
if ( (method == COAP_METHOD_GET)
|| (method == COAP_METHOD_PUT)
|| (method == COAP_METHOD_POST)
|| ( (method == COAP_METHOD_DELETE) && (value_len > 0) )
) {
// hand off handling of this to variable node.
return smcp_variable_handler_request_handler(&group->var_handler);
} else if (method == COAP_METHOD_DELETE) {
// Delete this group.
smcp_group_mgr_delete(self, group);
return smcp_outbound_quick_response(COAP_RESULT_202_DELETED, NULL);
}
} else {
ret = SMCP_STATUS_NOT_FOUND;
}
bail:
return ret;
}
