void coap_SendNotify(AddressType * addr, const char * path, const char * token, int tokenSize, ContentType contentType, const char * payload, int payloadLen, int sequence)
{
coap_packet_t notify;
coap_transaction_t *transaction;
Lwm2m_Debug("Coap notify: %s\n", path);
Lwm2m_Debug("Coap IPv6 request address: " PRINT6ADDR(&addr->Addr));
Lwm2m_Debug("Coap request port: %d\n", addr->Port);
coap_init_message(¬ify, COAP_TYPE_NON, CONTENT_2_05, coap_get_mid());
if (contentType != ContentType_None)
{
coap_set_header_content_format(¬ify, contentType);
coap_set_payload(¬ify, payload, payloadLen);
}
coap_set_token(¬ify, token, tokenSize);
coap_set_header_observe(¬ify, sequence);
if ((transaction = coap_new_transaction(notify.mid, &addr->Addr, uip_htons(addr->Port))))
{
transaction->packet_len = coap_serialize_message(¬ify, transaction->packet);
coap_send_transaction(transaction); // for NON confirmable messages this will call coap_clear_transaction();
}
}
void coap_SendNotify(AddressType * addr, const char * path, const char * token, int tokenSize, ContentType contentType,
const char * payload, int payloadLen, int sequence)
{
// TODO - FIXME: if path is not full uri then map addr to Network address + append path(?)
coap_packet_t notify;
coap_transaction_t *transaction;
NetworkAddress * remoteAddress = NetworkAddress_New(path, strlen(path));
Lwm2m_Debug("Coap notify: %s\n", path);
//Lwm2m_Debug("Coap IPv6 request address: " PRINT6ADDR(&addr->Addr));
//Lwm2m_Debug("Coap request port: %d\n", addr->Port);
coap_init_message(¬ify, COAP_TYPE_NON, CONTENT_2_05, coap_get_mid());
if (contentType != ContentType_None)
{
coap_set_header_content_format(¬ify, contentType);
coap_set_payload(¬ify, payload, payloadLen);
}
coap_set_token(¬ify, token, tokenSize);
coap_set_header_observe(¬ify, sequence);
if ((transaction = coap_new_transaction(networkSocket, notify.mid, remoteAddress)))
{
transaction->packet_len = coap_serialize_message(¬ify, transaction->packet);
coap_send_transaction(transaction); // for NON confirmable messages this will call coap_clear_transaction();
}
}
void coap_createCoapRequest(void * context, coap_method_t method, const char * uri, ContentType contentType, const char * payload, int payloadLen, TransactionCallback callback)
{
coap_packet_t request;
uip_ipaddr_t * remote_ipaddr = coap_getIpFromURI(uri);
int remote_port = coap_getPortFromURI(uri);
coap_transaction_t *transaction;
char path[128] = {0};
char query[128] = {0};
coap_getPathQueryFromURI(uri, path, query);
Lwm2m_Debug("Coap request: %s\n", uri);
Lwm2m_Debug("Coap IPv6 request address: " PRINT6ADDR(remote_ipaddr));
Lwm2m_Debug("Coap request port: %d\n", remote_port);
Lwm2m_Debug("Coap request path: %s\n", path);
Lwm2m_Debug("Coap request query: %s\n", query);
coap_init_message(&request, COAP_TYPE_CON, method, coap_get_mid());
coap_set_header_uri_path(&request, path);
coap_set_header_uri_query(&request, query);
if (contentType != ContentType_None)
{
coap_set_header_content_format(&request, contentType);
coap_set_payload(&request, payload, payloadLen);
}
if (CurrentTransaction[CurrentTransactionIndex].TransactionUsed && CurrentTransaction[CurrentTransactionIndex].TransactionPtr)
{
Lwm2m_Warning("Canceled previous transaction [%d]: %p\n", CurrentTransactionIndex, CurrentTransaction[CurrentTransactionIndex].TransactionPtr);
coap_clear_transaction(CurrentTransaction[CurrentTransactionIndex].TransactionPtr);
}
if ((transaction = coap_new_transaction(request.mid, remote_ipaddr, uip_htons(remote_port))))
{
transaction->callback = coap_CoapRequestCallback;
CurrentTransaction[CurrentTransactionIndex].Callback = callback;
CurrentTransaction[CurrentTransactionIndex].Context = context;
CurrentTransaction[CurrentTransactionIndex].TransactionUsed = true;
CurrentTransaction[CurrentTransactionIndex].TransactionPtr = transaction;
memcpy(&CurrentTransaction[CurrentTransactionIndex].Address.Addr, remote_ipaddr, sizeof(uip_ipaddr_t));
CurrentTransaction[CurrentTransactionIndex].Address.Port = uip_htons(remote_port);
transaction->callback_data = &CurrentTransaction[CurrentTransactionIndex];
transaction->packet_len = coap_serialize_message(&request, transaction->packet);
Lwm2m_Debug("Sending transaction [%d]: %p\n", CurrentTransactionIndex, CurrentTransaction[CurrentTransactionIndex].TransactionPtr);
coap_send_transaction(transaction);
CurrentTransactionIndex++;
if(CurrentTransactionIndex >= MAX_COAP_TRANSACTIONS)
{
CurrentTransactionIndex = 0;
}
}
}
void
oc_send_separate_response(oc_separate_response_t *handle,
oc_status_t response_code)
{
oc_response_buffer_t response_buffer;
response_buffer.buffer = handle->buffer;
response_buffer.response_length = response_length();
response_buffer.code = oc_status_code(response_code);
coap_separate_t *cur = oc_list_head(handle->requests), *next = NULL;
coap_packet_t response[1];
while (cur != NULL) {
next = cur->next;
if (cur->observe > 0) {
coap_transaction_t *t =
coap_new_transaction(coap_get_mid(), &cur->endpoint);
if (t) {
coap_separate_resume(response, cur, oc_status_code(response_code),
t->mid);
coap_set_header_content_format(response, APPLICATION_CBOR);
if (cur->observe == 1) {
coap_set_header_observe(response, 1);
}
if (response_buffer.response_length > 0) {
coap_set_payload(response, handle->buffer,
response_buffer.response_length);
}
t->message->length = coap_serialize_message(response, t->message->data);
coap_send_transaction(t);
}
coap_separate_clear(handle, cur);
} else {
if (coap_notify_observers(NULL, &response_buffer, &cur->endpoint) == 0) {
coap_separate_clear(handle, cur);
}
}
cur = next;
}
if (oc_list_length(handle->requests) == 0) {
handle->active = 0;
}
}
PROCESS_THREAD(poti, ev, data)
{
static struct etimer loop_timer;
PROCESS_BEGIN();
/* Initialize the REST engine. */
rest_init_engine ();
SERVER_NODE (&server_ipaddr);
adc_init ();
/* Activate the application-specific resources. */
#if PLATFORM_HAS_BATTERY
SENSORS_ACTIVATE(battery_sensor);
rest_activate_resource (&res_battery, "s/battery");
#endif
rest_activate_resource (&res_server_ip, "poti/ip");
rest_activate_resource (&res_server_resource, "poti/resource");
rest_activate_resource (&res_interval, "poti/interval");
etimer_set (&loop_timer, LOOP_INTERVAL);
/* Define application-specific events here. */
while(1) {
static int count = 0;
static int lastval = -1;
static coap_packet_t request [1]; /* Array: treat as pointer */
uint8_t val = 127;
PROCESS_WAIT_EVENT();
if (etimer_expired (&loop_timer)) {
uint16_t sum = 0;
int i;
count++;
adc_setup (ADC_DEFAULT, A5);
for (i=0; i<5; i++) {
sum += adc_read ();
clock_delay_usec (50);
}
adc_fin ();
val = (sum / 5) >> 2;
if ((interval > 0 && count > interval) || (val != lastval)) {
char buf [4];
coap_transaction_t *transaction;
sprintf (buf, "%d", val);
lastval = val;
printf ("Sending Value: %s\n", buf);
coap_init_message (request, COAP_TYPE_NON, COAP_PUT, 0);
coap_set_header_uri_path (request, server_resource);
coap_set_header_content_format (request, REST.type.TEXT_PLAIN);
coap_set_payload (request, buf, strlen (buf));
request->mid = coap_get_mid ();
transaction = coap_new_transaction
(request->mid, &server_ipaddr, REMOTE_PORT);
transaction->packet_len = coap_serialize_message
(request, transaction->packet);
coap_send_transaction (transaction);
count = 0;
}
etimer_reset (&loop_timer);
}
} /* while (1) */
void coap_createCoapRequest(coap_method_t method, const char * uri, ContentType contentType, ObserveState observeState,
const char * payload, int payloadLen, TransactionCallback callback, void * context)
{
coap_packet_t request;
char path[MAX_COAP_PATH] =
{ 0 };
char query[128] =
{ 0 };
coap_transaction_t *transaction;
NetworkAddress * remoteAddress = NetworkAddress_New(uri, strlen(uri));
coap_getPathQueryFromURI(uri, path, query);
Lwm2m_Info("Coap request: %s\n", uri);
//Lwm2m_Debug("Coap request path: %s\n", path);
//Lwm2m_Debug("Coap request query: %s\n", query);
coap_init_message(&request, COAP_TYPE_CON, method, coap_get_mid());
coap_set_header_uri_path(&request, path);
if (strlen(query) > 0)
coap_set_header_uri_query(&request, query);
// TODO - REVIEW: Erbium must copy path/query from request - else mem out of scope
if (contentType != ContentType_None)
{
if ((method == COAP_POST) || (method == COAP_PUT))
{
coap_set_header_content_format(&request, contentType);
coap_set_payload(&request, payload, payloadLen);
}
else
{
coap_set_header_accept(&request, contentType);
}
}
if (method == COAP_GET)
{
if (observeState == ObserveState_Establish)
{
coap_set_header_observe(&request, 0);
int token = addObserve(remoteAddress, path, callback, context);
if (token != 0)
coap_set_token(&request, (const uint8_t *) &token, sizeof(token));
}
else if (observeState == ObserveState_Cancel)
{
coap_set_header_observe(&request, 1);
int token = removeObserve(remoteAddress, path);
if (token != 0)
coap_set_token(&request, (const uint8_t *) &token, sizeof(token));
}
}
if (CurrentTransaction[CurrentTransactionIndex].TransactionUsed && CurrentTransaction[CurrentTransactionIndex].TransactionPtr)
{
Lwm2m_Warning("Canceled previous transaction [%d]: %p\n", CurrentTransactionIndex,
CurrentTransaction[CurrentTransactionIndex].TransactionPtr);
coap_clear_transaction(&CurrentTransaction[CurrentTransactionIndex].TransactionPtr);
}
//if ((transaction = coap_new_transaction(request.mid, remote_ipaddr, uip_htons(remote_port))))
if ((transaction = coap_new_transaction(networkSocket, request.mid, remoteAddress)))
{
transaction->callback = coap_CoapRequestCallback;
memcpy(CurrentTransaction[CurrentTransactionIndex].Path, path, MAX_COAP_PATH);
CurrentTransaction[CurrentTransactionIndex].Callback = callback;
CurrentTransaction[CurrentTransactionIndex].Context = context;
CurrentTransaction[CurrentTransactionIndex].TransactionUsed = true;
CurrentTransaction[CurrentTransactionIndex].TransactionPtr = transaction;
NetworkAddress_SetAddressType(remoteAddress, &CurrentTransaction[CurrentTransactionIndex].Address);
transaction->callback_data = &CurrentTransaction[CurrentTransactionIndex];
transaction->packet_len = coap_serialize_message(&request, transaction->packet);
Lwm2m_Debug("Sending transaction [%d]: %p\n", CurrentTransactionIndex, CurrentTransaction[CurrentTransactionIndex].TransactionPtr);
coap_send_transaction(transaction);
CurrentTransactionIndex++;
if (CurrentTransactionIndex >= MAX_COAP_TRANSACTIONS)
{
CurrentTransactionIndex = 0;
}
}
}
static int coap_HandleRequest(void *packet, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
int result = 1;
const char *url = NULL;
int urlLen = 0;
const uint8_t * payload = NULL;
int payloadLen = 0;
int content = -1;
coap_packet_t * const request = (coap_packet_t *) packet;
CoapResponse coapResponse =
{ .responseContent = buffer, .responseContentLen = preferred_size, .responseCode = 400, };
payloadLen = coap_get_payload(request, &payload);
if ((urlLen = coap_get_header_uri_path(request, &url)))
{
char uriBuf[MAX_COAP_PATH] = { 0 };
rest_resource_flags_t method = (rest_resource_flags_t) (1 << (((coap_packet_t *) packet)->code - 1)); //coap_get_rest_method(request);
uriBuf[0] = '/';
memcpy(&uriBuf[1], url, urlLen);
char queryBuf[128] = "?";
const char * query = NULL;
int queryLength = coap_get_header_uri_query(request, &query);
if (queryLength > 0)
memcpy(&queryBuf[1], query, queryLength);
queryBuf[queryLength+1] = '\0';
CoapRequest coapRequest =
{ .ctxt = context, .addr =
{ 0 }, .path = uriBuf, .query = queryBuf, .token = request->token, .tokenLength = request->token_len, .requestContent = payload,
.requestContentLen = payloadLen, };
NetworkAddress_SetAddressType(sourceAddress, &coapRequest.addr);
switch (method)
{
case METHOD_GET:
coap_get_header_accept(request, &content);
coapRequest.contentType = content;
int32_t observe;
if (!coap_get_header_observe(request, &observe))
observe = -1;
switch (observe)
{
case -1:
Lwm2m_Debug("Coap GET for %s\n", uriBuf);
coapRequest.type = COAP_GET_REQUEST;
requestHandler(&coapRequest, &coapResponse);
break;
case 0:
Lwm2m_Debug("Coap OBSERVE for %s\n", uriBuf);
coapRequest.type = COAP_OBSERVE_REQUEST;
requestHandler(&coapRequest, &coapResponse);
coap_set_header_observe(response, 1);
break;
case 1:
Lwm2m_Debug("Coap CANCEL OBSERVE for %s\n", uriBuf);
coapRequest.type = COAP_CANCEL_OBSERVE_REQUEST;
requestHandler(&coapRequest, &coapResponse);
break;
default:
break;
}
coap_set_header_content_format(response, coapResponse.responseContentType); /* text/plain is the default, hence this option could be omitted. */
break;
case METHOD_POST:
coap_get_header_content_format(request, &content);
coapRequest.contentType = content;
coapRequest.type = COAP_POST_REQUEST;
Lwm2m_Debug("Coap POST for %s\n", uriBuf);
requestHandler(&coapRequest, &coapResponse);
if (coapResponse.responseContentLen > 0 && coapResponse.responseCode == 201)
{
coap_set_header_location_path(response, coapResponse.responseContent);
}
break;
case METHOD_PUT:
coap_get_header_content_format(request, &content);
coapRequest.contentType = content;
coapRequest.type = COAP_PUT_REQUEST;
Lwm2m_Debug("Coap PUT for %s\n", uriBuf);
requestHandler(&coapRequest, &coapResponse);
break;
case METHOD_DELETE:
coapRequest.contentType = ContentType_None;
coapRequest.type = COAP_DELETE_REQUEST;
Lwm2m_Debug("Coap DELETE for %s\n", uriBuf);
requestHandler(&coapRequest, &coapResponse);
break;
default:
break;
}
if (coapResponse.responseContentLen > 0 && coapResponse.responseCode == 205)
{
coap_set_payload(response, coapResponse.responseContent, coapResponse.responseContentLen);
}
}
coap_set_status_code(response, COAP_RESPONSE_CODE(coapResponse.responseCode));
return result;
}
