coap_status_t observe_handleRequest(lwm2m_context_t * contextP,
lwm2m_uri_t * uriP,
lwm2m_server_t * serverP,
int size,
lwm2m_data_t * dataP,
coap_packet_t * message,
coap_packet_t * response)
{
lwm2m_watcher_t * watcherP;
uint32_t count;
LOG("observe_handleRequest()\r\n");
coap_get_header_observe(message, &count);
switch (count)
{
case 0:
if (!LWM2M_URI_IS_SET_INSTANCE(uriP) && LWM2M_URI_IS_SET_RESOURCE(uriP)) return COAP_400_BAD_REQUEST;
if (message->token_len == 0) return COAP_400_BAD_REQUEST;
watcherP = prv_getWatcher(contextP, uriP, serverP);
if (watcherP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
watcherP->tokenLen = message->token_len;
memcpy(watcherP->token, message->token, message->token_len);
watcherP->active = true;
watcherP->lastTime = lwm2m_gettime();
if (LWM2M_URI_IS_SET_RESOURCE(uriP))
{
switch (dataP->type)
{
case LWM2M_TYPE_INTEGER:
if (1 != lwm2m_data_decode_int(dataP, &(watcherP->lastValue.asInteger))) return COAP_500_INTERNAL_SERVER_ERROR;
break;
case LWM2M_TYPE_FLOAT:
if (1 != lwm2m_data_decode_float(dataP, &(watcherP->lastValue.asFloat))) return COAP_500_INTERNAL_SERVER_ERROR;
break;
default:
break;
}
}
coap_set_header_observe(response, watcherP->counter++);
return COAP_205_CONTENT;
case 1:
// cancellation
observe_cancel(contextP, LWM2M_MAX_ID, serverP->sessionH);
return COAP_205_CONTENT;
default:
return COAP_400_BAD_REQUEST;
}
}
/*---------------------------------------------------------------------------*/
static void
res_dc_status_obs_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
int vout_value = dc_status_sensor.value(0);
int vin_value = dc_status_sensor.value(1);
int iout_value = dc_status_sensor.value(2);
int iin_value = dc_status_sensor.value(3);
/* a request comes from a remote host */
if(request != NULL) {
#if PLATFORM_HAS_LEDS
/* set red led when receiving a packet */
leds_on(LEDS_RED);
#endif
coap_packet_t *const coap_req = (coap_packet_t *)request;
PRINTF("dcdc/status GET (%s %u)\n", coap_req->type == COAP_TYPE_CON ? "CON" : "NON", coap_req->mid);
/* if comes with observe then register it */
if(coap_get_header_observe(request, &observe)) {
/* PRINTF("OBSERVE set\n"); */
/* respond with empty ack */
REST.set_header_content_type(response, observe);
REST.set_response_payload(response, 0, 0);
} else { /* if no observe option, then answer to GET request as normal */
/* PRINTF("OBSERVE NOT set\n"); */
REST.set_header_content_type(response, REST.type.TEXT_PLAIN);
REST.set_response_payload(
response,
buffer,
snprintf((char *)buffer, MAX_COAP_PAYLOAD, "ST\tON\nVO\t%d.000\nIO\t%d.000\nVI\t%d.000\nII\t%d.000\n", vout_value, iout_value, vin_value, iin_value));
}
} else { /* this is a notification: need to set payload */
/* PRINTF("NULL REQUEST = PERIODIC\n"); */
REST.set_response_payload(
response,
buffer,
snprintf((char *)buffer, MAX_COAP_PAYLOAD, "ST\tON\nVO\t%d.000\nIO\t%d.000\nVI\t%d.000\nII\t%d.000\n", vout_value, iout_value, vin_value, iin_value));
}
count++;
printf("PERIODIC %d: ST:ON VO:%d IO:%d VI:%d II:%d\n", count, vout_value, iout_value, vin_value, iin_value);
#if PLATFORM_HAS_LEDS
/* set yellow led when sending packet */
leds_on(LEDS_YELLOW);
#endif
}
bool ICACHE_FLASH_ATTR
handle_observe_notify(lwm2m_context_t * contextP,
void * fromSessionH,
coap_packet_t * message,
coap_packet_t * response)
{
uint8_t * tokenP;
int token_len;
uint16_t clientID;
uint16_t obsID;
lwm2m_client_t * clientP;
lwm2m_observation_t * observationP;
uint32_t count;
token_len = coap_get_header_token(message, (const uint8_t **)&tokenP);
if (token_len != sizeof(uint32_t)) return false;
if (1 != coap_get_header_observe(message, &count)) return false;
clientID = (tokenP[0] << 8) | tokenP[1];
obsID = (tokenP[2] << 8) | tokenP[3];
clientP = (lwm2m_client_t *)lwm2m_list_find((lwm2m_list_t *)contextP->clientList, clientID);
if (clientP == NULL) return false;
observationP = (lwm2m_observation_t *)lwm2m_list_find((lwm2m_list_t *)clientP->observationList, obsID);
if (observationP == NULL)
{
coap_init_message(response, COAP_TYPE_RST, 0, message->mid);
message_send(contextP, response, fromSessionH);
}
else
{
if (message->type == COAP_TYPE_CON ) {
coap_init_message(response, COAP_TYPE_ACK, 0, message->mid);
message_send(contextP, response, fromSessionH);
}
observationP->callback(clientID,
&observationP->uri,
(int)count,
message->content_type, message->payload, message->payload_len,
observationP->userData);
}
return true;
}
void handle_observe_notify(lwm2m_context_t * contextP,
uint8_t * fromAddr,
size_t fromAddrLen,
coap_packet_t * message)
{
uint8_t * tokenP;
int token_len;
uint16_t clientID;
uint16_t obsID;
lwm2m_client_t * clientP;
lwm2m_observation_t * observationP;
uint32_t count;
token_len = coap_get_header_token(message, (const uint8_t **)&tokenP);
if (token_len != sizeof(uint32_t)) return;
if (1 != coap_get_header_observe(message, &count)) return;
clientID = (tokenP[0] << 8) | tokenP[1];
obsID = (tokenP[2] << 8) | tokenP[3];
clientP = (lwm2m_client_t *)lwm2m_list_find((lwm2m_list_t *)contextP->clientList, clientID);
if (clientP == NULL) return;
observationP = (lwm2m_observation_t *)lwm2m_list_find((lwm2m_list_t *)clientP->observationList, obsID);
if (observationP == NULL)
{
coap_packet_t resetMsg;
coap_init_message(&resetMsg, COAP_TYPE_RST, 0, message->mid);
message_send(contextP, &resetMsg, fromAddr, fromAddrLen);
}
else
{
observationP->callback(clientID,
&observationP->uri,
(int)count,
message->payload, message->payload_len,
observationP->userData);
}
}
void
mirror_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
/* The ETag and Token is copied to the header. */
uint8_t opaque[] = {0x0A, 0xBC, 0xDE};
/* Strings are not copied, so use static string buffers or strings in .text memory (char *str = "string in .text";). */
static char location[] = {'/','f','/','a','?','k','&','e', 0};
/* Getter for the header option Content-Type. If the option is not set, text/plain is returned by default. */
unsigned int content_type = REST.get_header_content_type(request);
/* The other getters copy the value (or string/array pointer) to the given pointers and return 1 for success or the length of strings/arrays. */
uint32_t max_age_and_size = 0;
const char *str = NULL;
uint32_t observe = 0;
const uint8_t *bytes = NULL;
uint32_t block_num = 0;
uint8_t block_more = 0;
uint16_t block_size = 0;
const char *query = "";
int len = 0;
/* Mirror the received header options in the response payload. Unsupported getters (e.g., rest_get_header_observe() with HTTP) will return 0. */
int strpos = 0;
/* snprintf() counts the terminating '\0' to the size parameter.
* The additional byte is taken care of by allocating REST_MAX_CHUNK_SIZE+1 bytes in the REST framework.
* Add +1 to fill the complete buffer, as the payload does not need a terminating '\0'. */
if (content_type!=-1)
{
strpos += snprintf((char *)buffer, REST_MAX_CHUNK_SIZE+1, "CT %u\n", content_type);
}
/* Some getters such as for ETag or Location are omitted, as these options should not appear in a request.
* Max-Age might appear in HTTP requests or used for special purposes in CoAP. */
if (strpos<=REST_MAX_CHUNK_SIZE && REST.get_header_max_age(request, &max_age_and_size))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "MA %lu\n", max_age_and_size);
}
/* For HTTP this is the Length option, for CoAP it is the Size option. */
if (strpos<=REST_MAX_CHUNK_SIZE && REST.get_header_length(request, &max_age_and_size))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "SZ %lu\n", max_age_and_size);
}
if (strpos<=REST_MAX_CHUNK_SIZE && (len = REST.get_header_host(request, &str)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "UH %.*s\n", len, str);
}
/* CoAP-specific example: actions not required for normal RESTful Web service. */
#if WITH_COAP > 1
if (strpos<=REST_MAX_CHUNK_SIZE && coap_get_header_observe(request, &observe))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Ob %lu\n", observe);
}
if (strpos<=REST_MAX_CHUNK_SIZE && (len = coap_get_header_token(request, &bytes)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "To 0x");
int index = 0;
for (index = 0; index<len; ++index) {
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "%02X", bytes[index]);
}
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "\n");
}
if (strpos<=REST_MAX_CHUNK_SIZE && (len = coap_get_header_etag(request, &bytes)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "ET 0x");
int index = 0;
for (index = 0; index<len; ++index) {
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "%02X", bytes[index]);
}
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "\n");
}
if (strpos<=REST_MAX_CHUNK_SIZE && (len = coap_get_header_uri_path(request, &str)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "UP ");
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "%.*s\n", len, str);
}
#if WITH_COAP == 3
if (strpos<=REST_MAX_CHUNK_SIZE && (len = coap_get_header_location(request, &str)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Lo %.*s\n", len, str);
}
if (strpos<=REST_MAX_CHUNK_SIZE && coap_get_header_block(request, &block_num, &block_more, &block_size, NULL)) /* This getter allows NULL pointers to get only a subset of the block parameters. */
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Bl %lu%s (%u)\n", block_num, block_more ? "+" : "", block_size);
}
#else
if (strpos<=REST_MAX_CHUNK_SIZE && (len = coap_get_header_location_path(request, &str)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "LP %.*s\n", len, str);
}
if (strpos<=REST_MAX_CHUNK_SIZE && (len = coap_get_header_location_query(request, &str)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "LQ %.*s\n", len, str);
}
if (strpos<=REST_MAX_CHUNK_SIZE && coap_get_header_block2(request, &block_num, &block_more, &block_size, NULL)) /* This getter allows NULL pointers to get only a subset of the block parameters. */
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "B2 %lu%s (%u)\n", block_num, block_more ? "+" : "", block_size);
}
/*
* Critical Block1 option is currently rejected by engine.
*
if (strpos<=REST_MAX_CHUNK_SIZE && coap_get_header_block1(request, &block_num, &block_more, &block_size, NULL))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "B1 %lu%s (%u)\n", block_num, block_more ? "+" : "", block_size);
}
*/
#endif /* CoAP > 03 */
#endif /* CoAP-specific example */
if (strpos<=REST_MAX_CHUNK_SIZE && (len = REST.get_query(request, &query)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Qu %.*s\n", len, query);
}
if (strpos<=REST_MAX_CHUNK_SIZE && (len = REST.get_request_payload(request, &bytes)))
{
strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "%.*s", len, bytes);
}
if (strpos >= REST_MAX_CHUNK_SIZE)
{
buffer[REST_MAX_CHUNK_SIZE-1] = 0xBB; /* 'ยป' to indicate truncation */
}
REST.set_response_payload(response, buffer, strpos);
PRINTF("/mirror options received: %s\n", buffer);
/* Set dummy header options for response. Like getters, some setters are not implemented for HTTP and have no effect. */
REST.set_header_content_type(response, REST.type.TEXT_PLAIN);
REST.set_header_max_age(response, 17); /* For HTTP, browsers will not re-request the page for 17 seconds. */
REST.set_header_etag(response, opaque, 2);
REST.set_header_location(response, location); /* Initial slash is omitted by framework */
REST.set_header_length(response, strpos); /* For HTTP, browsers will not re-request the page for 10 seconds. CoAP action depends on the client. */
/* CoAP-specific example: actions not required for normal RESTful Web service. */
#if WITH_COAP > 1
coap_set_header_uri_host(response, "tiki");
coap_set_header_observe(response, 10);
#if WITH_COAP == 3
coap_set_header_block(response, 42, 0, 64); /* The block option might be overwritten by the framework when blockwise transfer is requested. */
#else
coap_set_header_proxy_uri(response, "ftp://x");
coap_set_header_block2(response, 42, 0, 64); /* The block option might be overwritten by the framework when blockwise transfer is requested. */
coap_set_header_block1(response, 23, 0, 16);
coap_set_header_accept(response, TEXT_PLAIN);
coap_set_header_if_none_match(response);
#endif /* CoAP > 03 */
#endif /* CoAP-specific example */
}
static void coap_HandleResource(/*CoapRequestHandlerCallbacks * RequestCB,*/ void *packet, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
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 = REST.get_request_payload(request, &payload);
if ((urlLen = REST.get_url(request, &url)))
{
char uriBuf[64] = {0};
rest_resource_flags_t method = REST.get_method_type(request);
uriBuf[0] = '/';
memcpy(&uriBuf[1], url, urlLen);
const char * query = NULL;
REST.get_query(request, &query);
CoapRequest coapRequest = {
.ctxt = context,
.addr = { 0 },
.path = uriBuf,
.query = query,
.token = request->token,
.tokenLength = request->token_len,
.requestContent = payload,
.requestContentLen = payloadLen,
};
memcpy(&coapRequest.addr.Addr, &UIP_IP_BUF->srcipaddr, sizeof(uip_ipaddr_t));
coapRequest.addr.Port = uip_ntohs(UIP_UDP_BUF->srcport);
switch(method)
{
case METHOD_GET:
REST.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;
}
REST.set_header_content_type(response, coapResponse.responseContentType); /* text/plain is the default, hence this option could be omitted. */
break;
case METHOD_POST:
REST.get_header_content_type(request, &content);
coapRequest.contentType = content;
coapRequest.type = COAP_POST_REQUEST;
Lwm2m_Debug("Coap POST for %s\n", uriBuf);
requestHandler(&coapRequest, &coapResponse);
break;
case METHOD_PUT:
REST.get_header_content_type(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 )
{
REST.set_response_payload(response, coapResponse.responseContent, coapResponse.responseContentLen);
}
}
REST.set_response_status(response, COAP_RESPONSE_CODE(coapResponse.responseCode));
}
/*----------------------------------------------------------------------------*/
static
int
coap_receive(void)
{
coap_error_code = NO_ERROR;
PRINTF("handle_incoming_data(): received uip_datalen=%u \n",(uint16_t)uip_datalen());
/* Static declaration reduces stack peaks and program code size. */
static coap_packet_t message[1]; /* This way the packet can be treated as pointer as usual. */
static coap_packet_t response[1];
static coap_transaction_t *transaction = NULL;
if (uip_newdata()) {
PRINTF("receiving UDP datagram from: ");
PRINT6ADDR(&UIP_IP_BUF->srcipaddr);
PRINTF(":%u\n Length: %u\n Data: ", uip_ntohs(UIP_UDP_BUF->srcport), uip_datalen() );
PRINTBITS(uip_appdata, uip_datalen());
PRINTF("\n");
coap_error_code = coap_parse_message(message, uip_appdata, uip_datalen());
if (coap_error_code==NO_ERROR)
{
/*TODO duplicates suppression, if required by application */
PRINTF(" Parsed: v %u, t %u, tkl %u, c %u, mid %u\n", message->version, message->type, message->token_len, message->code, message->mid);
PRINTF(" URL: %.*s\n", message->uri_path_len, message->uri_path);
PRINTF(" Payload: %.*s\n", message->payload_len, message->payload);
/* Handle requests. */
if (message->code >= COAP_GET && message->code <= COAP_DELETE)
{
/* Use transaction buffer for response to confirmable request. */
if ( (transaction = coap_new_transaction(message->mid, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport)) )
{
uint32_t block_num = 0;
uint16_t block_size = REST_MAX_CHUNK_SIZE;
uint32_t block_offset = 0;
int32_t new_offset = 0;
/* prepare response */
if (message->type==COAP_TYPE_CON)
{
/* Reliable CON requests are answered with an ACK. */
coap_init_message(response, COAP_TYPE_ACK, CONTENT_2_05, message->mid);
}
else
{
/* Unreliable NON requests are answered with a NON as well. */
coap_init_message(response, COAP_TYPE_NON, CONTENT_2_05, coap_get_mid());
}
/* mirror token */
if (message->token_len)
{
coap_set_header_token(response, message->token, message->token_len);
}
/* get offset for blockwise transfers */
if (coap_get_header_block2(message, &block_num, NULL, &block_size, &block_offset))
{
PRINTF("Blockwise: block request %lu (%u/%u) @ %lu bytes\n", block_num, block_size, REST_MAX_CHUNK_SIZE, block_offset);
block_size = MIN(block_size, REST_MAX_CHUNK_SIZE);
new_offset = block_offset;
}
/* Invoke resource handler. */
if (service_cbk)
{
/* Call REST framework and check if found and allowed. */
if (service_cbk(message, response, transaction->packet+COAP_MAX_HEADER_SIZE, block_size, &new_offset))
{
if (coap_error_code==NO_ERROR)
{
/* Apply blockwise transfers. */
if ( IS_OPTION(message, COAP_OPTION_BLOCK1) && response->code<BAD_REQUEST_4_00 && !IS_OPTION(response, COAP_OPTION_BLOCK1) )
{
PRINTF("Block1 NOT IMPLEMENTED\n");
coap_error_code = NOT_IMPLEMENTED_5_01;
coap_error_message = "NoBlock1Support";
}
else if ( IS_OPTION(message, COAP_OPTION_BLOCK2) )
{
/* unchanged new_offset indicates that resource is unaware of blockwise transfer */
if (new_offset==block_offset)
{
PRINTF("Blockwise: unaware resource with payload length %u/%u\n", response->payload_len, block_size);
if (block_offset >= response->payload_len)
{
PRINTF("handle_incoming_data(): block_offset >= response->payload_len\n");
response->code = BAD_OPTION_4_02;
coap_set_payload(response, "BlockOutOfScope", 15); /* a const char str[] and sizeof(str) produces larger code size */
}
else
{
coap_set_header_block2(response, block_num, response->payload_len - block_offset > block_size, block_size);
coap_set_payload(response, response->payload+block_offset, MIN(response->payload_len - block_offset, block_size));
} /* if (valid offset) */
}
else
{
/* resource provides chunk-wise data */
PRINTF("Blockwise: blockwise resource, new offset %ld\n", new_offset);
coap_set_header_block2(response, block_num, new_offset!=-1 || response->payload_len > block_size, block_size);
if (response->payload_len > block_size) coap_set_payload(response, response->payload, block_size);
} /* if (resource aware of blockwise) */
}
else if (new_offset!=0)
{
PRINTF("Blockwise: no block option for blockwise resource, using block size %u\n", REST_MAX_CHUNK_SIZE);
coap_set_header_block2(response, 0, new_offset!=-1, REST_MAX_CHUNK_SIZE);
coap_set_payload(response, response->payload, MIN(response->payload_len, REST_MAX_CHUNK_SIZE));
} /* if (blockwise request) */
} /* no errors/hooks */
} /* successful service callback */
/* Serialize response. */
if (coap_error_code==NO_ERROR)
{
if ((transaction->packet_len = coap_serialize_message(response, transaction->packet))==0)
{
coap_error_code = PACKET_SERIALIZATION_ERROR;
}
}
}
else
{
coap_error_code = NOT_IMPLEMENTED_5_01;
coap_error_message = "NoServiceCallbck"; // no a to fit 16 bytes
} /* if (service callback) */
} else {
coap_error_code = SERVICE_UNAVAILABLE_5_03;
coap_error_message = "NoFreeTraBuffer";
} /* if (transaction buffer) */
}
else
{
/* Responses */
uint32_t observe = 0;
coap_subscription_t *subscription;
coap_transaction_t *open_transaction = NULL;
transaction = NULL;
if (message->type==COAP_TYPE_CON && message->code==0)
{
PRINTF("Received Ping\n");
coap_error_code = PING_RESPONSE;
}
else if (message->type==COAP_TYPE_ACK)
{
/* Transactions are closed through lookup below */
PRINTF("Received ACK\n");
}
else if (message->type==COAP_TYPE_RST)
{
PRINTF("Received RST\n");
/* Cancel possible subscriptions. */
coap_remove_observer_by_mid(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, message->mid);
}
else if (coap_get_header_observe(message, &observe))
{
PRINTF("Received a notification on a subscription\n");
if (message->type==COAP_TYPE_CON) // notifications can be confirmable or not
{
PRINTF("creating ACK for confirmable notification\n");
if ( (transaction = coap_new_transaction(message->mid, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport)))
{
/* Reliable CON requests are answered with an ACK. */
coap_init_message(response, COAP_TYPE_ACK, CONTENT_2_05, message->mid);
/* mirror token */
if (message->token_len)
{
coap_set_header_token(response, message->token, message->token_len);
}
else
{
PRINTF("No token in notification from observed resource?\n");
}
}
else
{
/* TODO: correct to send 5.03? */
coap_error_code = SERVICE_UNAVAILABLE_5_03;
coap_error_message = "NoFreeTraBuffer";
}
} /* if (confirmable notification) */
if (message->token_len)
{
if ((subscription = coap_get_subscription_by_token(message->token, message->token_len)))
{
if (message->code == CONTENT_2_05 || message->code == VALID_2_03)
{
// now passing the message to the handler that also handled the repsonce of the first subscription GET
subscription->callback(message);
}
else
{
// the server sent a non valid notification, indicating that the resource is no longer valid
coap_clear_subscription(subscription);
}
}
else
{
PRINTF("No handler found for notification based on token\n");
}
}
else
{
PRINTF("No token in notification from observed resource!?\n");
} /* notification had a token, which it should */
} /* received notification from observed resource */
if ( (open_transaction = coap_get_transaction_by_mid(message->mid)) )
{
/* Free transaction memory before callback, as it may create a new transaction. */
restful_response_handler callback = transaction->callback;
void *callback_data = transaction->callback_data;
coap_clear_transaction(transaction);
/* Check if someone registered for the response */
if (callback) {
callback(callback_data, message);
}
} /* if (ACKed transaction) */
transaction = NULL;
} /* Request or Response */
} /* if (parsed correctly) */
if (coap_error_code==NO_ERROR)
{
if (transaction) coap_send_transaction(transaction);
}
else if (coap_error_code==MANUAL_RESPONSE)
{
PRINTF("Clearing transaction for manual response");
coap_clear_transaction(transaction);
}
else
{
coap_message_type_t reply_type = COAP_TYPE_ACK;
PRINTF("ERROR %u: %s\n", coap_error_code, coap_error_message);
coap_clear_transaction(transaction);
/* Set to sendable error code. */
if (coap_error_code >= 192)
{
coap_error_code = INTERNAL_SERVER_ERROR_5_00;
}
if (coap_error_code == PING_RESPONSE)
{
coap_error_code = 0;
reply_type = COAP_TYPE_RST;
}
/* Reuse input buffer for error message. */
coap_init_message(message, reply_type, coap_error_code, message->mid);
coap_set_payload(message, coap_error_message, strlen(coap_error_message));
coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, uip_appdata, coap_serialize_message(message, uip_appdata));
}
} /* if (new data) */
return coap_error_code;
}
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;
}
