From f71b0bc794cde3781fcc9fa70046ffd69f412e9d Mon Sep 17 00:00:00 2001 From: Matthias Kovatsch Date: Wed, 14 Sep 2011 16:33:01 +0200 Subject: [PATCH] Added Erbium REST engine with new CoAP implementation --- apps/er-coap-03/Makefile.er-coap-03 | 1 + apps/er-coap-03/er-coap-03-engine.c | 559 +++++++++ apps/er-coap-03/er-coap-03-engine.h | 91 ++ apps/er-coap-03/er-coap-03-observing.c | 199 +++ apps/er-coap-03/er-coap-03-observing.h | 76 ++ apps/er-coap-03/er-coap-03-transactions.c | 177 +++ apps/er-coap-03/er-coap-03-transactions.h | 78 ++ apps/er-coap-03/er-coap-03.c | 769 ++++++++++++ apps/er-coap-03/er-coap-03.h | 284 +++++ apps/er-coap-06/Makefile.er-coap-06 | 1 + apps/er-coap-06/er-coap-06-engine.c | 564 +++++++++ apps/er-coap-06/er-coap-06-engine.h | 92 ++ apps/er-coap-06/er-coap-06-observing.c | 201 +++ apps/er-coap-06/er-coap-06-observing.h | 76 ++ apps/er-coap-06/er-coap-06-separate.c | 72 ++ apps/er-coap-06/er-coap-06-separate.h | 50 + apps/er-coap-06/er-coap-06-transactions.c | 194 +++ apps/er-coap-06/er-coap-06-transactions.h | 79 ++ apps/er-coap-06/er-coap-06.c | 986 +++++++++++++++ apps/er-coap-06/er-coap-06.h | 300 +++++ apps/er-coap-07/Makefile.er-coap-07 | 1 + apps/er-coap-07/er-coap-07-engine.c | 565 +++++++++ apps/er-coap-07/er-coap-07-engine.h | 92 ++ apps/er-coap-07/er-coap-07-observing.c | 218 ++++ apps/er-coap-07/er-coap-07-observing.h | 80 ++ apps/er-coap-07/er-coap-07-separate.c | 69 ++ apps/er-coap-07/er-coap-07-separate.h | 46 + apps/er-coap-07/er-coap-07-transactions.c | 195 +++ apps/er-coap-07/er-coap-07-transactions.h | 78 ++ apps/er-coap-07/er-coap-07.c | 1098 +++++++++++++++++ apps/er-coap-07/er-coap-07.h | 319 +++++ apps/erbium/Makefile.erbium | 1 + apps/erbium/erbium.c | 263 ++++ apps/erbium/erbium.h | 331 +++++ examples/er-rest-example/Makefile | 69 ++ examples/er-rest-example/README | 67 + .../er-rest-example/coap-client-example.c | 174 +++ .../coap-client-server-example.csc | 227 ++++ examples/er-rest-example/project-conf.h | 65 + .../er-rest-example/rest-server-example.c | 594 +++++++++ .../er-rest-example/rest-server-example.csc | 188 +++ examples/er-rest-example/static-routing.c | 155 +++ examples/er-rest-example/static-routing.h | 20 + 43 files changed, 9764 insertions(+) create mode 100644 apps/er-coap-03/Makefile.er-coap-03 create mode 100644 apps/er-coap-03/er-coap-03-engine.c create mode 100644 apps/er-coap-03/er-coap-03-engine.h create mode 100644 apps/er-coap-03/er-coap-03-observing.c create mode 100644 apps/er-coap-03/er-coap-03-observing.h create mode 100644 apps/er-coap-03/er-coap-03-transactions.c create mode 100644 apps/er-coap-03/er-coap-03-transactions.h create mode 100644 apps/er-coap-03/er-coap-03.c create mode 100644 apps/er-coap-03/er-coap-03.h create mode 100644 apps/er-coap-06/Makefile.er-coap-06 create mode 100644 apps/er-coap-06/er-coap-06-engine.c create mode 100644 apps/er-coap-06/er-coap-06-engine.h create mode 100644 apps/er-coap-06/er-coap-06-observing.c create mode 100644 apps/er-coap-06/er-coap-06-observing.h create mode 100644 apps/er-coap-06/er-coap-06-separate.c create mode 100644 apps/er-coap-06/er-coap-06-separate.h create mode 100644 apps/er-coap-06/er-coap-06-transactions.c create mode 100644 apps/er-coap-06/er-coap-06-transactions.h create mode 100644 apps/er-coap-06/er-coap-06.c create mode 100644 apps/er-coap-06/er-coap-06.h create mode 100644 apps/er-coap-07/Makefile.er-coap-07 create mode 100644 apps/er-coap-07/er-coap-07-engine.c create mode 100644 apps/er-coap-07/er-coap-07-engine.h create mode 100644 apps/er-coap-07/er-coap-07-observing.c create mode 100644 apps/er-coap-07/er-coap-07-observing.h create mode 100644 apps/er-coap-07/er-coap-07-separate.c create mode 100644 apps/er-coap-07/er-coap-07-separate.h create mode 100644 apps/er-coap-07/er-coap-07-transactions.c create mode 100644 apps/er-coap-07/er-coap-07-transactions.h create mode 100644 apps/er-coap-07/er-coap-07.c create mode 100644 apps/er-coap-07/er-coap-07.h create mode 100644 apps/erbium/Makefile.erbium create mode 100644 apps/erbium/erbium.c create mode 100644 apps/erbium/erbium.h create mode 100644 examples/er-rest-example/Makefile create mode 100644 examples/er-rest-example/README create mode 100644 examples/er-rest-example/coap-client-example.c create mode 100644 examples/er-rest-example/coap-client-server-example.csc create mode 100644 examples/er-rest-example/project-conf.h create mode 100644 examples/er-rest-example/rest-server-example.c create mode 100644 examples/er-rest-example/rest-server-example.csc create mode 100644 examples/er-rest-example/static-routing.c create mode 100644 examples/er-rest-example/static-routing.h diff --git a/apps/er-coap-03/Makefile.er-coap-03 b/apps/er-coap-03/Makefile.er-coap-03 new file mode 100644 index 000000000..c308c18d5 --- /dev/null +++ b/apps/er-coap-03/Makefile.er-coap-03 @@ -0,0 +1 @@ +er-coap-03_src = er-coap-03-engine.c er-coap-03.c er-coap-03-transactions.c er-coap-03-observing.c diff --git a/apps/er-coap-03/er-coap-03-engine.c b/apps/er-coap-03/er-coap-03-engine.c new file mode 100644 index 000000000..44be0dc57 --- /dev/null +++ b/apps/er-coap-03/er-coap-03-engine.c @@ -0,0 +1,559 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP implementation of the REST Engine + * \author + * Matthias Kovatsch + */ + +#include +#include +#include +#include "contiki.h" +#include "contiki-net.h" + +#include "er-coap-03-engine.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF(" %02x:%02x:%02x:%02x:%02x:%02x ",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#define PRINTBITS(buf,len) { \ + int i,j=0; \ + for (i=0; i=0; --j) { \ + PRINTF("%c", (((char *)buf)[i] & 1<srcipaddr); + PRINTF(":%u\n Length: %u\n Data: ", uip_ntohs(UIP_UDP_BUF->srcport), data_len ); + PRINTBITS(data, data_len); + PRINTF("\n"); + + coap_packet_t message[1]; + coap_transaction_t *transaction = NULL; + + error = coap_parse_message(message, data, data_len); + + if (error==NO_ERROR) + { + + /*TODO duplicates suppression, if required */ + + PRINTF(" Parsed: v %u, t %u, oc %u, c %u, tid %u\n", message->version, message->type, message->option_count, message->code, message->tid); + 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->tid, &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 */ + coap_packet_t response[1]; /* This way the packet can be treated as pointer as usual. */ + if (message->type==COAP_TYPE_CON) + { + /* Reliable CON requests are answered with an ACK. */ + coap_init_message(response, COAP_TYPE_ACK, OK_200, message->tid); + } + else + { + /* Unreliable NON requests are answered with a NON as well. */ + coap_init_message(response, COAP_TYPE_NON, OK_200, coap_get_tid()); + } + + /* resource handlers must take care of different handling (e.g., TOKEN_OPTION_REQUIRED_240) */ + if (IS_OPTION(message, COAP_OPTION_TOKEN)) + { + coap_set_header_token(response, message->token, message->token_len); + SET_OPTION(response, COAP_OPTION_TOKEN); + } + + /* get offset for blockwise transfers */ + if (coap_get_header_block(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; + } + + /*------------------------------------------*/ + /* call application-specific handler */ + /*------------------------------------------*/ + if (service_cbk) { + service_cbk(message, response, transaction->packet+COAP_MAX_HEADER_SIZE, block_size, &new_offset); + } + /*------------------------------------------*/ + + + /* apply blockwise transfers */ + if ( IS_OPTION(message, COAP_OPTION_BLOCK) ) + { + /* 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) + { + response->code = BAD_REQUEST_400; + coap_set_payload(response, (uint8_t*)"Block out of scope", 18); + } + else + { + coap_set_header_block(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_block(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_block(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) */ + + if ((transaction->packet_len = coap_serialize_message(response, transaction->packet))==0) + { + error = PACKET_SERIALIZATION_ERROR; + } + + } else { + error = MEMORY_ALLOC_ERR; + } + } + else + { + /* Responses */ + coap_transaction_t *t; + + if (message->type==COAP_TYPE_ACK) + { + PRINTF("Received ACK\n"); + } + else if (message->type==COAP_TYPE_RST) + { + PRINTF("Received RST\n"); + /* Cancel possible subscriptions. */ + if (IS_OPTION(message, COAP_OPTION_TOKEN)) + { + PRINTF(" Token 0x%02X%02X\n", message->token[0], message->token[1]); + coap_remove_observer_by_token(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, message->token, message->token_len); + } + } + + if ( (t = coap_get_transaction_by_tid(message->tid)) ) + { + /* Free transaction memory before callback, as it may create a new transaction. */ + restful_response_handler callback = t->callback; + void *callback_data = t->callback_data; + coap_clear_transaction(t); + + /* Check if someone registered for the response */ + if (callback) { + callback(callback_data, message); + } + } /* if (transaction) */ + } + } /* if (parsed correctly) */ + + if (error==NO_ERROR) { + if (transaction) coap_send_transaction(transaction); + } + else + { + PRINTF("ERROR %u: %s\n", error, error_messages[error]); + + /* reuse input buffer */ + coap_init_message(message, COAP_TYPE_ACK, INTERNAL_SERVER_ERROR_500, message->tid); + coap_set_payload(message, (uint8_t *) error_messages[error], strlen(error_messages[error])); + coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, data, coap_serialize_message(message, data)); + } + } /* if (new data) */ + + return error; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_receiver_init() +{ + process_start(&coap_receiver, NULL); +} +/*-----------------------------------------------------------------------------------*/ +void +coap_set_service_callback(service_callback_t callback) +{ + service_cbk = callback; +} +/*-----------------------------------------------------------------------------------*/ +rest_resource_flags_t +coap_get_rest_method(void *packet) +{ + return (rest_resource_flags_t)(1 << (((coap_packet_t *)packet)->code - 1)); +} +/*-----------------------------------------------------------------------------------*/ +int +coap_set_rest_status(void *packet, unsigned int code) +{ + if (code <= 0xFF) + { + ((coap_packet_t *)packet)->code = (uint8_t) code; + return 1; + } + else + { + return 0; + } +} +/*-----------------------------------------------------------------------------------*/ +/*- Server part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +/* The discover resource should be included when using CoAP. */ +RESOURCE(well_known_core, METHOD_GET, ".well-known/core", ""); +void +well_known_core_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + /* Response might be NULL for non-confirmable requests. */ + if (response) + { + size_t strpos = 0; + size_t bufpos = 0; + resource_t* resource = NULL; + + for (resource = (resource_t*)list_head(rest_get_resources()); resource; resource = resource->next) + { + strpos += snprintf((char *) buffer + bufpos, REST_MAX_CHUNK_SIZE - bufpos + 1, + "%s%s%s", + resource->url, + resource->attributes[0] ? ";" : "", + resource->attributes, + resource->next ? "," : "" ); + + PRINTF("discover: %s\n", resource->url); + + if (strpos <= *offset) + { + /* Discard output before current block */ + PRINTF(" if %d <= %ld B\n", strpos, *offset); + PRINTF(" %s\n", buffer); + bufpos = 0; + } + else /* (strpos > *offset) */ + { + /* output partly in block */ + size_t len = MIN(strpos - *offset, preferred_size); + + PRINTF(" el %d/%d @ %ld B\n", len, preferred_size, *offset); + + /* Block might start in the middle of the output; align with buffer start. */ + if (bufpos == 0) + { + memmove(buffer, buffer+strlen((char *)buffer)-strpos+*offset, len); + } + + bufpos = len; + PRINTF(" %s\n", buffer); + + if (bufpos >= preferred_size) + { + break; + } + } + } + + if (bufpos>0) { + coap_set_payload(response, buffer, bufpos ); + coap_set_header_content_type(response, APPLICATION_LINK_FORMAT); + } + else + { + coap_set_rest_status(response, BAD_REQUEST_400); + coap_set_payload(response, (uint8_t*)"Block out of scope", 18); + } + + if (resource==NULL) { + *offset = -1; + } + else + { + *offset += bufpos; + } + } +} +/*-----------------------------------------------------------------------------------*/ +PROCESS_THREAD(coap_receiver, ev, data) +{ + PROCESS_BEGIN(); + PRINTF("Starting CoAP-03 receiver...\n"); + + rest_activate_resource(&resource_well_known_core); + + coap_register_as_transaction_handler(); + coap_init_connection(SERVER_LISTEN_PORT); + + while(1) { + PROCESS_YIELD(); + + if(ev == tcpip_event) { + handle_incoming_data(); + } else if (ev == PROCESS_EVENT_TIMER) { + /* retransmissions are handled here */ + coap_check_transactions(); + } + } /* while (1) */ + + PROCESS_END(); +} +/*-----------------------------------------------------------------------------------*/ +/*- Client part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void blocking_request_callback(void *callback_data, void *response) { + struct request_state_t *state = (struct request_state_t *) callback_data; + state->response = (coap_packet_t*) response; + process_poll(state->process); +} +/*-----------------------------------------------------------------------------------*/ +PT_THREAD(coap_blocking_request(struct request_state_t *state, process_event_t ev, + uip_ipaddr_t *remote_ipaddr, uint16_t remote_port, + coap_packet_t *request, + blocking_response_handler request_callback)) { + PT_BEGIN(&state->pt); + + static uint8_t more; + static uint32_t res_block; + static uint8_t block_error; + + state->block_num = 0; + state->response = NULL; + state->process = PROCESS_CURRENT(); + + more = 0; + res_block = 0; + block_error = 0; + + do { + request->tid = coap_get_tid(); + if ((state->transaction = coap_new_transaction(request->tid, remote_ipaddr, remote_port))) + { + state->transaction->callback = blocking_request_callback; + state->transaction->callback_data = state; + + if (state->block_num>0) + { + coap_set_header_block(request, state->block_num, 0, REST_MAX_CHUNK_SIZE); + } + + state->transaction->packet_len = coap_serialize_message(request, state->transaction->packet); + + coap_send_transaction(state->transaction); + PRINTF("Requested #%lu (TID %u)\n", state->block_num, request->tid); + + PT_YIELD_UNTIL(&state->pt, ev == PROCESS_EVENT_POLL); + + if (!state->response) + { + PRINTF("Server not responding\n"); + PT_EXIT(&state->pt); + } + + coap_get_header_block(state->response, &res_block, &more, NULL, NULL); + + PRINTF("Received #%lu%s (%u bytes)\n", res_block, more ? "+" : "", state->response->payload_len); + + if (res_block==state->block_num) + { + request_callback(state->response); + ++(state->block_num); + } + else + { + PRINTF("WRONG BLOCK %lu/%lu\n", res_block, state->block_num); + ++block_error; + } + } + else + { + PRINTF("Could not allocate transaction buffer"); + PT_EXIT(&state->pt); + } + } while (more && block_errorpt); +} +/*-----------------------------------------------------------------------------------*/ +/*- Engine Interface ----------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +const struct rest_implementation coap_rest_implementation = { + "CoAP-03", + + coap_receiver_init, + coap_set_service_callback, + + coap_get_header_uri_path, + coap_set_header_uri_path, + coap_get_rest_method, + coap_set_rest_status, + + coap_get_header_content_type, + coap_set_header_content_type, + NULL, + coap_get_header_max_age, + coap_set_header_max_age, + coap_set_header_etag, + NULL, + NULL, + coap_get_header_uri_host, + coap_set_header_location, + + coap_get_payload, + coap_set_payload, + + coap_get_header_uri_query, + coap_get_query_variable, + coap_get_post_variable, + + coap_notify_observers, + (restful_post_handler) coap_observe_handler, + + NULL, + NULL, + + { + OK_200, + CREATED_201, + OK_200, + OK_200, + NOT_MODIFIED_304, + + BAD_REQUEST_400, + METHOD_NOT_ALLOWED_405, + BAD_REQUEST_400, + METHOD_NOT_ALLOWED_405, + NOT_FOUND_404, + METHOD_NOT_ALLOWED_405, + BAD_REQUEST_400, + UNSUPPORTED_MADIA_TYPE_415, + + INTERNAL_SERVER_ERROR_500, + CRITICAL_OPTION_NOT_SUPPORTED, + BAD_GATEWAY_502, + SERVICE_UNAVAILABLE_503, + GATEWAY_TIMEOUT_504, + INTERNAL_SERVER_ERROR_500 + }, + + { + TEXT_PLAIN, + TEXT_XML, + TEXT_CSV, + TEXT_HTML, + IMAGE_GIF, + IMAGE_JPEG, + IMAGE_PNG, + IMAGE_TIFF, + AUDIO_RAW, + VIDEO_RAW, + APPLICATION_LINK_FORMAT, + APPLICATION_XML, + APPLICATION_OCTET_STREAM, + APPLICATION_RDF_XML, + APPLICATION_SOAP_XML, + APPLICATION_ATOM_XML, + APPLICATION_XMPP_XML, + APPLICATION_EXI, + APPLICATION_FASTINFOSET, + APPLICATION_SOAP_FASTINFOSET, + APPLICATION_JSON, + APPLICATION_OCTET_STREAM + } +}; diff --git a/apps/er-coap-03/er-coap-03-engine.h b/apps/er-coap-03/er-coap-03-engine.h new file mode 100644 index 000000000..3d8ab7afd --- /dev/null +++ b/apps/er-coap-03/er-coap-03-engine.h @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP implementation of the REST Engine + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_SERVER_H_ +#define COAP_SERVER_H_ + +#if !defined(REST) +#error "Define REST to \"coap_rest_implementation\"" +#endif + +#include "er-coap-03.h" +#include "er-coap-03-transactions.h" +#include "er-coap-03-observing.h" + +#include "pt.h" + +/* Declare server process */ +PROCESS_NAME(coap_receiver); + +#define SERVER_LISTEN_PORT UIP_HTONS(COAP_SERVER_PORT) + +typedef coap_packet_t rest_request_t; +typedef coap_packet_t rest_response_t; + +extern const struct rest_implementation coap_rest_implementation; + +void coap_receiver_init(void); + +/*-----------------------------------------------------------------------------------*/ +/*- Client part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +struct request_state_t { + struct pt pt; + struct process *process; + coap_transaction_t *transaction; + coap_packet_t *response; + uint32_t block_num; +}; + +typedef void (*blocking_response_handler) (void* response); + +PT_THREAD(coap_blocking_request(struct request_state_t *state, process_event_t ev, + uip_ipaddr_t *remote_ipaddr, uint16_t remote_port, + coap_packet_t *request, + blocking_response_handler request_callback)); + +#define COAP_BLOCKING_REQUEST(server_addr, server_port, request, chunk_handler) \ +static struct request_state_t request_state; \ +PT_SPAWN(process_pt, &request_state.pt, \ + coap_blocking_request(&request_state, ev, \ + server_addr, server_port, \ + request, chunk_handler) \ + ); +/*-----------------------------------------------------------------------------------*/ + +#endif /* COAP_SERVER_H_ */ diff --git a/apps/er-coap-03/er-coap-03-observing.c b/apps/er-coap-03/er-coap-03-observing.c new file mode 100644 index 000000000..82e8cbffa --- /dev/null +++ b/apps/er-coap-03/er-coap-03-observing.c @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for observing resources + * \author + * Matthias Kovatsch + */ + +#include +#include + +#include "er-coap-03-observing.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +MEMB(observers_memb, coap_observer_t, COAP_MAX_OBSERVERS); +LIST(observers_list); + +/*-----------------------------------------------------------------------------------*/ +coap_observer_t * +coap_add_observer(const char *url, uip_ipaddr_t *addr, uint16_t port, const uint8_t *token, size_t token_len) +{ + coap_observer_t *o = memb_alloc(&observers_memb); + + if (o) + { + o->url = url; + uip_ipaddr_copy(&o->addr, addr); + o->port = port; + o->token_len = token_len; + memcpy(o->token, token, token_len); + + stimer_set(&o->refresh_timer, COAP_OBSERVING_REFRESH_INTERVAL); + + PRINTF("Adding observer for /%s [0x%02X%02X]\n", o->url, o->token[0], o->token[1]); + list_add(observers_list, o); + } + + return o; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_remove_observer(coap_observer_t *o) +{ + PRINTF("Removing observer for /%s [0x%02X%02X]\n", o->url, o->token[0], o->token[1]); + + memb_free(&observers_memb, o); + list_remove(observers_list, o); +} + +int +coap_remove_observer_by_client(uip_ipaddr_t *addr, uint16_t port) +{ + int removed = 0; + coap_observer_t* obs = NULL; + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + PRINTF("Remove check Port %u\n", port); + if (uip_ipaddr_cmp(&obs->addr, addr) && obs->port==port) + { + coap_remove_observer(obs); + removed++; + } + } + return removed; +} +int +coap_remove_observer_by_token(uip_ipaddr_t *addr, uint16_t port, uint8_t *token, size_t token_len) +{ + int removed = 0; + coap_observer_t* obs = NULL; + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + PRINTF("Remove check Token 0x%02X%02X\n", token[0], token[1]); + if (uip_ipaddr_cmp(&obs->addr, addr) && obs->port==port && memcmp(obs->token, token, token_len)==0) + { + coap_remove_observer(obs); + removed++; + } + } + return removed; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_notify_observers(const char *url, int type, uint32_t observe, uint8_t *payload, size_t payload_len) +{ + coap_observer_t* obs = NULL; + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + if (obs->url==url) /* using RESOURCE url string as handle */ + { + coap_transaction_t *transaction = NULL; + + /*TODO implement special transaction for CON, sharing the same buffer to allow for more observers */ + + if ( (transaction = coap_new_transaction(coap_get_tid(), &obs->addr, obs->port)) ) + { + /* Use CON to check whether client is still there/interested after COAP_OBSERVING_REFRESH_INTERVAL. */ + if (stimer_expired(&obs->refresh_timer)) + { + PRINTF("Observing: Refresh client with CON\n"); + type = COAP_TYPE_CON; + stimer_restart(&obs->refresh_timer); + } + + /* prepare response */ + coap_packet_t push[1]; /* This way the packet can be treated as pointer as usual. */ + coap_init_message(push, (coap_message_type_t)type, OK_200, transaction->tid ); + coap_set_header_observe(push, observe); + coap_set_header_token(push, obs->token, obs->token_len); + coap_set_payload(push, payload, payload_len); + transaction->packet_len = coap_serialize_message(push, transaction->packet); + + PRINTF("Observing: Notify from /%s for ", url); + PRINT6ADDR(&obs->addr); + PRINTF(":%u\n", obs->port); + PRINTF(" %.*s\n", payload_len, payload); + + coap_send_transaction(transaction); + } + } + } +} +/*-----------------------------------------------------------------------------------*/ +void +coap_observe_handler(resource_t *resource, void *request, void *response) +{ + static char content[26]; + + if (response && ((coap_packet_t *)response)->code<128) /* response without error code */ + { + if (IS_OPTION((coap_packet_t *)request, COAP_OPTION_OBSERVE)) + { + if (IS_OPTION((coap_packet_t *)request, COAP_OPTION_TOKEN)) + { + if (coap_add_observer(resource->url, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, ((coap_packet_t *)request)->token, ((coap_packet_t *)request)->token_len)) + { + coap_set_header_observe(response, 0); + coap_set_payload(response, (uint8_t *)content, snprintf(content, sizeof(content), "Added as observer %u/%u", list_length(observers_list), COAP_MAX_OBSERVERS)); + } + else + { + ((coap_packet_t *)response)->code = SERVICE_UNAVAILABLE_503; + coap_set_payload(response, (uint8_t *)"Too many observers", 18); + } /* if (added observer) */ + } + else /* if (token) */ + { + ((coap_packet_t *)response)->code = TOKEN_OPTION_REQUIRED; + coap_set_payload(response, (uint8_t *)"Observing requires token", 24); + } /* if (token) */ + } + else /* if (observe) */ + { + /* Remove client if it is currently observing. */ + coap_remove_observer_by_client(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport); + } /* if (observe) */ + } +} diff --git a/apps/er-coap-03/er-coap-03-observing.h b/apps/er-coap-03/er-coap-03-observing.h new file mode 100644 index 000000000..90cbdf0b0 --- /dev/null +++ b/apps/er-coap-03/er-coap-03-observing.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for observing resources + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_OBSERVING_H_ +#define COAP_OBSERVING_H_ + +#include "er-coap-03.h" +#include "er-coap-03-transactions.h" + +#ifndef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS 4 +#endif /* COAP_MAX_OBSERVERS */ + +/* Interval in seconds in which NON notifies are changed to CON notifies to check client. */ +#define COAP_OBSERVING_REFRESH_INTERVAL 60 + +#if COAP_MAX_OPEN_TRANSACTIONS + */ + +#include "contiki.h" +#include "contiki-net.h" + +#include "er-coap-03-transactions.h" +#include "er-coap-03-observing.h" + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +MEMB(transactions_memb, coap_transaction_t, COAP_MAX_OPEN_TRANSACTIONS); +LIST(transactions_list); + + +static struct process *transaction_handler_process = NULL; + +void +coap_register_as_transaction_handler() +{ + transaction_handler_process = PROCESS_CURRENT(); +} + +coap_transaction_t * +coap_new_transaction(uint16_t tid, uip_ipaddr_t *addr, uint16_t port) +{ + coap_transaction_t *t = memb_alloc(&transactions_memb); + + if (t) + { + t->tid = tid; + t->retrans_counter = 0; + + /* save client address */ + uip_ipaddr_copy(&t->addr, addr); + t->port = port; + } + + return t; +} + +void +coap_send_transaction(coap_transaction_t *t) +{ + PRINTF("Sending transaction %u\n", t->tid); + + coap_send_message(&t->addr, t->port, t->packet, t->packet_len); + + if (COAP_TYPE_CON==((COAP_HEADER_TYPE_MASK & t->packet[0])>>COAP_HEADER_TYPE_POSITION)) + { + if (t->retrans_countertid); + + /*FIXME hack, maybe there is a better way, but avoid posting everything to the process */ + struct process *process_actual = PROCESS_CURRENT(); + process_current = transaction_handler_process; + etimer_set(&t->retrans_timer, CLOCK_SECOND * COAP_RESPONSE_TIMEOUT * (1<<(t->retrans_counter))); + process_current = process_actual; + + list_add(transactions_list, t); /* list itself makes sure same element is not added twice */ + + t = NULL; + } + else + { + /* timeout */ + PRINTF("Timeout\n"); + restful_response_handler callback = t->callback; + void *callback_data = t->callback_data; + + /* handle observers */ + coap_remove_observer_by_client(&t->addr, t->port); + + coap_clear_transaction(t); + + if (callback) { + callback(callback_data, NULL); + } + } + } + else + { + coap_clear_transaction(t); + } +} + +void +coap_clear_transaction(coap_transaction_t *t) +{ + if (t) + { + PRINTF("Freeing transaction %u: %p\n", t->tid, t); + + etimer_stop(&t->retrans_timer); + list_remove(transactions_list, t); + memb_free(&transactions_memb, t); + } +} + +coap_transaction_t * +coap_get_transaction_by_tid(uint16_t tid) +{ + coap_transaction_t *t = NULL; + + for (t = (coap_transaction_t*)list_head(transactions_list); t; t = t->next) + { + if (t->tid==tid) + { + PRINTF("Found transaction for TID %u: %p\n", t->tid, t); + return t; + } + } + return NULL; +} + +void +coap_check_transactions() +{ + coap_transaction_t *t = NULL; + + for (t = (coap_transaction_t*)list_head(transactions_list); t; t = t->next) + { + if (etimer_expired(&t->retrans_timer)) + { + ++(t->retrans_counter); + PRINTF("Retransmitting %u (%u)\n", t->tid, t->retrans_counter); + coap_send_transaction(t); + } + } +} diff --git a/apps/er-coap-03/er-coap-03-transactions.h b/apps/er-coap-03/er-coap-03-transactions.h new file mode 100644 index 000000000..b109fa992 --- /dev/null +++ b/apps/er-coap-03/er-coap-03-transactions.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for reliable transport + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_TRANSACTIONS_H_ +#define COAP_TRANSACTIONS_H_ + +#include "er-coap-03.h" + +/* + * The number of concurrent messages that can be stored for retransmission in the transaction layer. + */ +#ifndef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 4 +#endif /* COAP_MAX_OPEN_TRANSACTIONS */ + +/* container for transactions with message buffer and retransmission info */ +typedef struct coap_transaction { + struct coap_transaction *next; /* for LIST */ + + uint16_t tid; + struct etimer retrans_timer; + uint8_t retrans_counter; + + uip_ipaddr_t addr; + uint16_t port; + + restful_response_handler callback; + void *callback_data; + + uint16_t packet_len; + uint8_t packet[COAP_MAX_PACKET_SIZE+1]; /* +1 for the terminating '\0' to simply and savely use snprintf(buf, len+1, "", ...) in the resource handler. */ +} coap_transaction_t; + +void coap_register_as_transaction_handler(); + +coap_transaction_t *coap_new_transaction(uint16_t tid, uip_ipaddr_t *addr, uint16_t port); +void coap_send_transaction(coap_transaction_t *t); +void coap_clear_transaction(coap_transaction_t *t); +coap_transaction_t *coap_get_transaction_by_tid(uint16_t tid); + +void coap_check_transactions(); + +#endif /* COAP_TRANSACTIONS_H_ */ diff --git a/apps/er-coap-03/er-coap-03.c b/apps/er-coap-03/er-coap-03.c new file mode 100644 index 000000000..220af6be2 --- /dev/null +++ b/apps/er-coap-03/er-coap-03.c @@ -0,0 +1,769 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * An implementation of the Constrained Application Protocol (draft 03) + * \author + * Matthias Kovatsch + */ + +#ifdef CONTIKI_TARGET_NETSIM + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#else + #include "contiki.h" + #include "contiki-net.h" + #include + #include +#endif + +#include "er-coap-03.h" +#include "er-coap-03-transactions.h" + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +static struct uip_udp_conn *udp_conn = NULL; +static uint16_t current_tid = 0; + +/*-----------------------------------------------------------------------------------*/ +/*- LOCAL HELP FUNCTIONS ------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +static +uint16_t +log_2(uint16_t value) +{ + uint16_t result = 0; + do { + value = value >> 1; + result++; + } while (value); + + return result ? result - 1 : result; +} +/*-----------------------------------------------------------------------------------*/ +static +uint32_t +bytes_2_uint32(uint8_t *bytes, uint16_t length) +{ + uint32_t var = 0; + int i = 0; + while (i>8; + bytes[i++] = 0xFF & var; + + return i; +} +*/ +/*-----------------------------------------------------------------------------------*/ +static +int +uint32_2_bytes(uint8_t *bytes, uint32_t var) +{ + int i = 0; + if (0xFF000000 & var) bytes[i++] = var>>24; + if (0xFF0000 & var) bytes[i++] = var>>16; + if (0xFF00 & var) bytes[i++] = var>>8; + bytes[i++] = 0xFF & var; + + return i; +} +/*-----------------------------------------------------------------------------------*/ +static +int +coap_get_variable(const char *buffer, size_t length, const char *name, const char **output) +{ + const char *start = NULL; + const char *end = NULL; + const char *value_end = NULL; + size_t name_len = 0; + + /*initialize the output buffer first*/ + *output = 0; + + name_len = strlen(name); + end = buffer + length; + + for (start = buffer; start + name_len < end; ++start){ + if ((start == buffer || start[-1] == '&') && start[name_len] == '=' && + strncmp(name, start, name_len)==0) { + + /* Point start to variable value */ + start += name_len + 1; + + /* Point end to the end of the value */ + value_end = (const char *) memchr(start, '&', end - start); + if (value_end == NULL) { + value_end = end; + } + + *output = start; + + return (value_end - start); + } + } + + return 0; +} +/*-----------------------------------------------------------------------------------*/ +/*- MEASSAGE SENDING ----------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void +coap_init_connection(uint16_t port) +{ + /* new connection with remote host */ + udp_conn = udp_new(NULL, 0, NULL); + udp_bind(udp_conn, port); + PRINTF("Listening on port %u\n", uip_ntohs(udp_conn->lport)); + + /* Initialize transaction ID. */ + current_tid = random_rand(); +} +/*-----------------------------------------------------------------------------------*/ +uint16_t +coap_get_tid() +{ + ++current_tid; + PRINTF("Get TID %u\n", current_tid); + return current_tid; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_send_message(uip_ipaddr_t *addr, uint16_t port, uint8_t *data, uint16_t length) +{ + /*configure connection to reply to client*/ + uip_ipaddr_copy(&udp_conn->ripaddr, addr); + udp_conn->rport = port; + + uip_udp_packet_send(udp_conn, data, length); + PRINTF("-sent UDP datagram------\n Length: %u\n -----------------------\n", length); + + /* Restore server connection to allow data from any node */ + memset(&udp_conn->ripaddr, 0, sizeof(udp_conn->ripaddr)); + udp_conn->rport = 0; +} +/*-----------------------------------------------------------------------------------*/ +/*- MEASSAGE PROCESSING -------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void +coap_init_message(void *packet, coap_message_type_t type, uint8_t code, uint16_t tid) +{ + memset(packet, 0, sizeof(coap_packet_t)); + + ((coap_packet_t *)packet)->type = type; + ((coap_packet_t *)packet)->code = code; + ((coap_packet_t *)packet)->tid = tid; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_serialize_message(void *packet, uint8_t *buffer) +{ + ((coap_packet_t *)packet)->buffer = buffer; + ((coap_packet_t *)packet)->version = 1; + ((coap_packet_t *)packet)->option_count = 0; + + /* serialize options */ + uint8_t *option = ((coap_packet_t *)packet)->buffer + COAP_HEADER_LEN; + size_t option_len = 0; + int index = 0; + + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE)) { + ((coap_header_option_t *)option)->s.delta = 1; + ((coap_header_option_t *)option)->s.length = 1; + *(++option) = ((coap_packet_t *)packet)->content_type; + PRINTF("OPTION %u (type %u, len 1, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_CONTENT_TYPE, COAP_OPTION_CONTENT_TYPE - index); + PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type); + index = COAP_OPTION_CONTENT_TYPE; + option += 1; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) { + option_len = uint32_2_bytes(option+1, ((coap_packet_t *)packet)->max_age); + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_MAX_AGE - index; + ((coap_header_option_t *)option)->s.length = option_len; + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_MAX_AGE, option_len, COAP_OPTION_MAX_AGE - index); + PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age); + index = COAP_OPTION_MAX_AGE; + option += 1 + option_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) { + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_ETAG - index; + ((coap_header_option_t *)option)->s.length = ((coap_packet_t *)packet)->etag_len; + memcpy(++option, ((coap_packet_t *)packet)->etag, ((coap_packet_t *)packet)->etag_len); + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_ETAG, ((coap_packet_t *)packet)->etag_len, COAP_OPTION_ETAG - index); + PRINTF("ETag %u [0x%02X", ((coap_packet_t *)packet)->etag_len, ((coap_packet_t *)packet)->etag[0]); /*FIXME always prints 4 bytes */ + PRINTF("%02X", ((coap_packet_t *)packet)->etag[1]); + PRINTF("%02X", ((coap_packet_t *)packet)->etag[2]); + PRINTF("%02X", ((coap_packet_t *)packet)->etag[3]); + PRINTF("]\n"); + index = COAP_OPTION_ETAG; + option += ((coap_packet_t *)packet)->etag_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) { + if (((coap_packet_t *)packet)->uri_host_len<15) { + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_URI_HOST - index; + ((coap_header_option_t *)option)->s.length = ((coap_packet_t *)packet)->uri_host_len; + option += 1; + } else { + ((coap_header_option_t *)option)->l.delta = COAP_OPTION_URI_HOST - index; + ((coap_header_option_t *)option)->s.length = 15; + ((coap_header_option_t *)option)->l.length = ((coap_packet_t *)packet)->uri_host_len - 15; + option += 2; + } + memcpy(option, ((coap_packet_t *)packet)->uri_host, ((coap_packet_t *)packet)->uri_host_len); + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_URI_HOST, ((coap_packet_t *)packet)->uri_host_len, COAP_OPTION_URI_HOST - index); + PRINTF("Uri-Auth [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host); + index = COAP_OPTION_URI_HOST; + option += ((coap_packet_t *)packet)->uri_host_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) { + if (((coap_packet_t *)packet)->location_path_len<15) { + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_LOCATION_PATH - index; + ((coap_header_option_t *)option)->s.length = ((coap_packet_t *)packet)->location_path_len; + option += 1; + } else { + ((coap_header_option_t *)option)->l.delta = COAP_OPTION_LOCATION_PATH - index; + ((coap_header_option_t *)option)->s.length = 15; + ((coap_header_option_t *)option)->l.length = ((coap_packet_t *)packet)->location_path_len - 15; + option += 2; + } + memcpy(option, ((coap_packet_t *)packet)->location_path, ((coap_packet_t *)packet)->location_path_len); + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_LOCATION_PATH, ((coap_packet_t *)packet)->location_path_len, COAP_OPTION_LOCATION_PATH - index); + PRINTF("Location [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path); + index = COAP_OPTION_LOCATION_PATH; + option += ((coap_packet_t *)packet)->location_path_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) { + if (((coap_packet_t *)packet)->uri_path_len<15) { + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_URI_PATH - index; + ((coap_header_option_t *)option)->s.length = ((coap_packet_t *)packet)->uri_path_len; + option += 1; + } else { + ((coap_header_option_t *)option)->l.delta = COAP_OPTION_URI_PATH - index; + ((coap_header_option_t *)option)->s.length = 15; + ((coap_header_option_t *)option)->l.length = ((coap_packet_t *)packet)->uri_path_len - 15; + option += 2; + } + memcpy(option, ((coap_packet_t *)packet)->uri_path, ((coap_packet_t *)packet)->uri_path_len); + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_URI_PATH, ((coap_packet_t *)packet)->uri_path_len, COAP_OPTION_URI_PATH - index); + PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path); + index = COAP_OPTION_URI_PATH; + option += ((coap_packet_t *)packet)->uri_path_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) { + option_len = uint32_2_bytes(option+1, ((coap_packet_t *)packet)->observe); + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_OBSERVE - index; + ((coap_header_option_t *)option)->s.length = option_len; + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_OBSERVE, option_len, COAP_OPTION_OBSERVE - index); + PRINTF("Observe [%lu]\n", ((coap_packet_t *)packet)->observe); + index = COAP_OPTION_OBSERVE; + option += 1 + option_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) { + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_TOKEN - index; + ((coap_header_option_t *)option)->s.length = ((coap_packet_t *)packet)->token_len; + memcpy(++option, ((coap_packet_t *)packet)->token, ((coap_packet_t *)packet)->token_len); + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_TOKEN, ((coap_packet_t *)packet)->token_len, COAP_OPTION_TOKEN - index); + PRINTF("Token %u [0x%02X%02X]\n", ((coap_packet_t *)packet)->token_len, ((coap_packet_t *)packet)->token[0], ((coap_packet_t *)packet)->token[1]); /*FIXME always prints 2 bytes */ + index = COAP_OPTION_TOKEN; + option += ((coap_packet_t *)packet)->token_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK)) { + uint32_t block = ((coap_packet_t *)packet)->block_num << 4; + if (((coap_packet_t *)packet)->block_more) block |= 0x8; + block |= 0xF & log_2(((coap_packet_t *)packet)->block_size/16); + option_len = uint32_2_bytes(option+1, block); + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_BLOCK - index; + ((coap_header_option_t *)option)->s.length = option_len; + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_BLOCK, option_len, COAP_OPTION_BLOCK - index); + PRINTF("Block [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block_num, ((coap_packet_t *)packet)->block_more ? "+" : "", ((coap_packet_t *)packet)->block_size); + index = COAP_OPTION_BLOCK; + option += 1 + option_len; + ++(((coap_packet_t *)packet)->option_count); + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) { + if (((coap_packet_t *)packet)->uri_query_len<15) { + ((coap_header_option_t *)option)->s.delta = COAP_OPTION_URI_QUERY - index; + ((coap_header_option_t *)option)->s.length = ((coap_packet_t *)packet)->uri_query_len; + option += 1; + } else { + ((coap_header_option_t *)option)->l.delta = COAP_OPTION_URI_QUERY - index; + ((coap_header_option_t *)option)->s.length = 15; + ((coap_header_option_t *)option)->l.length = ((coap_packet_t *)packet)->uri_query_len - 15; + option += 2; + } + memcpy(option, ((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len); + PRINTF("OPTION %u (type %u, len %u, delta %u): ", ((coap_packet_t *)packet)->option_count, COAP_OPTION_URI_QUERY, ((coap_packet_t *)packet)->uri_query_len, COAP_OPTION_URI_QUERY - index); + PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query); + index = COAP_OPTION_URI_QUERY; + option += ((coap_packet_t *)packet)->uri_query_len; + ++(((coap_packet_t *)packet)->option_count); + } + + /* pack payload */ + if ((option - ((coap_packet_t *)packet)->buffer)<=COAP_MAX_HEADER_SIZE) + { + memmove(option, ((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len); + } + else + { + /* An error occured. Caller must check for !=0. */ + return 0; + } + + /* set header fields */ + ((coap_packet_t *)packet)->buffer[0] = 0x00; + ((coap_packet_t *)packet)->buffer[0] |= COAP_HEADER_VERSION_MASK & (((coap_packet_t *)packet)->version)<buffer[0] |= COAP_HEADER_TYPE_MASK & (((coap_packet_t *)packet)->type)<buffer[0] |= COAP_HEADER_OPTION_COUNT_MASK & (((coap_packet_t *)packet)->option_count)<buffer[1] = ((coap_packet_t *)packet)->code; + ((coap_packet_t *)packet)->buffer[2] = 0xFF & (((coap_packet_t *)packet)->tid)>>8; + ((coap_packet_t *)packet)->buffer[3] = 0xFF & ((coap_packet_t *)packet)->tid; + + PRINTF("Serialized %u options, header len %u, payload len %u\n", ((coap_packet_t *)packet)->option_count, option - ((coap_packet_t *)packet)->buffer, ((coap_packet_t *)packet)->payload_len); + + return (option - ((coap_packet_t *)packet)->buffer) + ((coap_packet_t *)packet)->payload_len; /* packet length */ +} +/*-----------------------------------------------------------------------------------*/ +error_t +coap_parse_message(void *packet, uint8_t *data, uint16_t data_len) +{ + /* Initialize packet */ + memset(packet, 0, sizeof(coap_packet_t)); + + /* pointer to packet bytes */ + ((coap_packet_t *)packet)->buffer = data; + + /* parse header fields */ + ((coap_packet_t *)packet)->version = (COAP_HEADER_VERSION_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_VERSION_POSITION; + ((coap_packet_t *)packet)->type = (COAP_HEADER_TYPE_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_TYPE_POSITION; + ((coap_packet_t *)packet)->option_count = (COAP_HEADER_OPTION_COUNT_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_OPTION_COUNT_POSITION; + ((coap_packet_t *)packet)->code = ((coap_packet_t *)packet)->buffer[1]; + ((coap_packet_t *)packet)->tid = ((coap_packet_t *)packet)->buffer[2]<<8 | ((coap_packet_t *)packet)->buffer[3]; + + /* parse options */ + ((coap_packet_t *)packet)->options = 0x0000; + coap_header_option_t *current_option = (coap_header_option_t *) (data + COAP_HEADER_LEN); + + if (((coap_packet_t *)packet)->option_count) { + uint8_t option_index = 0; + uint8_t option_type = 0; + + uint16_t option_len = 0; + uint8_t *option_data = NULL; + + uint8_t *last_option = NULL; + + for (option_index=0; option_index < ((coap_packet_t *)packet)->option_count; ++option_index) { + + option_type += current_option->s.delta; + + if (current_option->s.length<15) { + option_len = current_option->s.length; + option_data = ((uint8_t *) current_option) + 1; + } else { + option_len = current_option->l.length + 15; + option_data = ((uint8_t *) current_option) + 2; + } + + PRINTF("OPTION %u (type %u, len %u, delta %u): ", option_index, option_type, option_len, current_option->s.delta); + + SET_OPTION((coap_packet_t *)packet, option_type); + + switch (option_type) { + case COAP_OPTION_CONTENT_TYPE: + ((coap_packet_t *)packet)->content_type = option_data[0]; + PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type); + break; + case COAP_OPTION_MAX_AGE: + ((coap_packet_t *)packet)->max_age = bytes_2_uint32(option_data, option_len); + PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age); + break; + case COAP_OPTION_ETAG: + ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, option_len); + memcpy(((coap_packet_t *)packet)->etag, option_data, ((coap_packet_t *)packet)->etag_len); + PRINTF("ETag %u [0x%02X", ((coap_packet_t *)packet)->etag_len, ((coap_packet_t *)packet)->etag[0]); /*FIXME always prints 4 bytes */ + PRINTF("%02X", ((coap_packet_t *)packet)->etag[1]); + PRINTF("%02X", ((coap_packet_t *)packet)->etag[2]); + PRINTF("%02X", ((coap_packet_t *)packet)->etag[3]); + PRINTF("]\n"); + break; + case COAP_OPTION_URI_HOST: + ((coap_packet_t *)packet)->uri_host = (char *) option_data; + ((coap_packet_t *)packet)->uri_host_len = option_len; + PRINTF("Uri-Auth [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host); + break; + case COAP_OPTION_LOCATION_PATH: + ((coap_packet_t *)packet)->location_path = (char *) option_data; + ((coap_packet_t *)packet)->location_path_len = option_len; + PRINTF("Location [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path); + break; + case COAP_OPTION_URI_PATH: + ((coap_packet_t *)packet)->uri_path = (char *) option_data; + ((coap_packet_t *)packet)->uri_path_len = option_len; + PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path); + break; + case COAP_OPTION_OBSERVE: + ((coap_packet_t *)packet)->observe = bytes_2_uint32(option_data, option_len); + PRINTF("Observe [%lu]\n", ((coap_packet_t *)packet)->observe); + break; + case COAP_OPTION_TOKEN: + ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, option_len); + memcpy(((coap_packet_t *)packet)->token, option_data, ((coap_packet_t *)packet)->token_len); + PRINTF("Token %u [0x%02X%02X]\n", ((coap_packet_t *)packet)->token_len, ((coap_packet_t *)packet)->token[0], ((coap_packet_t *)packet)->token[1]); /*FIXME always prints 2 bytes */ + break; + case COAP_OPTION_BLOCK: + ((coap_packet_t *)packet)->block_num = bytes_2_uint32(option_data, option_len); + ((coap_packet_t *)packet)->block_more = (((coap_packet_t *)packet)->block_num & 0x08)>>3; + ((coap_packet_t *)packet)->block_size = 16 << (((coap_packet_t *)packet)->block_num & 0x07); + ((coap_packet_t *)packet)->block_offset = (((coap_packet_t *)packet)->block_num & ~0x0F)<<(((coap_packet_t *)packet)->block_num & 0x07); + ((coap_packet_t *)packet)->block_num >>= 4; + PRINTF("Block [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block_num, ((coap_packet_t *)packet)->block_more ? "+" : "", ((coap_packet_t *)packet)->block_size); + break; + case COAP_OPTION_NOOP: + PRINTF("Noop-Fencepost\n"); + break; + case COAP_OPTION_URI_QUERY: + ((coap_packet_t *)packet)->uri_query = (char *) option_data; + ((coap_packet_t *)packet)->uri_query_len = option_len; + PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query); + break; + default: + PRINTF("unknown (%u)\n", option_type); + if (option_type & 1) + { + return UNKNOWN_CRITICAL_OPTION; + } + } + + /* terminate strings where possible */ + if (last_option) { + last_option[0] = 0x00; + } + + last_option = (uint8_t *) current_option; + current_option = (coap_header_option_t *) (option_data+option_len); + } /* for () */ + } /* if (oc) */ + + ((coap_packet_t *)packet)->payload = (uint8_t *) current_option; + ((coap_packet_t *)packet)->payload_len = data_len - (((coap_packet_t *)packet)->payload - data); + + return NO_ERROR; +} +/*-----------------------------------------------------------------------------------*/ +/*- REST FRAMEWORK FUNCTIONS --------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +int +coap_get_query_variable(void *packet, const char *name, const char **output) +{ + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) { + return coap_get_variable(((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len, name, output); + } + return 0; +} + +int +coap_get_post_variable(void *packet, const char *name, const char **output) +{ + if (((coap_packet_t *)packet)->payload_len) { + return coap_get_variable((const char *)((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len, name, output); + } + return 0; +} +/*-----------------------------------------------------------------------------------*/ +/*- HEADER OPTION GETTERS AND SETTERS -----------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +unsigned int +coap_get_header_content_type(void *packet) +{ + return ((coap_packet_t *)packet)->content_type; +} + +int +coap_set_header_content_type(void *packet, unsigned int content_type) +{ + ((coap_packet_t *)packet)->content_type = (coap_content_type_t) content_type; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_max_age(void *packet, uint32_t *age) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) { + *age = COAP_DEFAULT_MAX_AGE; + } else { + *age = ((coap_packet_t *)packet)->max_age; + } + return 1; +} + +int +coap_set_header_max_age(void *packet, uint32_t age) +{ + ((coap_packet_t *)packet)->max_age = age; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_etag(void *packet, const uint8_t **etag) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) return 0; + + *etag = ((coap_packet_t *)packet)->etag; + return ((coap_packet_t *)packet)->etag_len; +} + +int +coap_set_header_etag(void *packet, uint8_t *etag, size_t etag_len) +{ + ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, etag_len); + memcpy(((coap_packet_t *)packet)->etag, etag, ((coap_packet_t *)packet)->etag_len); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG); + return ((coap_packet_t *)packet)->etag_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_host(void *packet, const char **host) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) return 0; + + *host = ((coap_packet_t *)packet)->uri_host; + return ((coap_packet_t *)packet)->uri_host_len; +} + +int +coap_set_header_uri_host(void *packet, char *host) +{ + ((coap_packet_t *)packet)->uri_host = (char *) host; + ((coap_packet_t *)packet)->uri_host_len = strlen(host); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST); + return ((coap_packet_t *)packet)->uri_host_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_location(void *packet, const char **uri) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) return 0; + + *uri = ((coap_packet_t *)packet)->location_path; + return ((coap_packet_t *)packet)->location_path_len; +} + +int +coap_set_header_location(void *packet, char *location) +{ + while (location[0]=='/') ++location; + + ((coap_packet_t *)packet)->location_path = (char *) location; + ((coap_packet_t *)packet)->location_path_len = strlen(location); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH); + return ((coap_packet_t *)packet)->location_path_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_path(void *packet, const char **path) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) return 0; + + *path = ((coap_packet_t *)packet)->uri_path; + return ((coap_packet_t *)packet)->uri_path_len; +} + +int +coap_set_header_uri_path(void *packet, char *path) +{ + while (path[0]=='/') ++path; + + ((coap_packet_t *)packet)->uri_path = (char *) path; + ((coap_packet_t *)packet)->uri_path_len = strlen(path); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH); + return ((coap_packet_t *)packet)->uri_path_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_observe(void *packet, uint32_t *observe) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) return 0; + + *observe = ((coap_packet_t *)packet)->observe; + return 1; +} + +int +coap_set_header_observe(void *packet, uint32_t observe) +{ + ((coap_packet_t *)packet)->observe = observe; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_token(void *packet, const uint8_t **token) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) return 0; + + *token = ((coap_packet_t *)packet)->token; + return ((coap_packet_t *)packet)->token_len; +} + +int +coap_set_header_token(void *packet, uint8_t *token, size_t token_len) +{ + ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, token_len); + memcpy(((coap_packet_t *)packet)->token, token, ((coap_packet_t *)packet)->token_len); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN); + return ((coap_packet_t *)packet)->token_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_block(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK)) return 0; + + /* pointers may be NULL to get only specific block parameters */ + if (num!=NULL) *num = ((coap_packet_t *)packet)->block_num; + if (more!=NULL) *more = ((coap_packet_t *)packet)->block_more; + if (size!=NULL) *size = ((coap_packet_t *)packet)->block_size; + if (offset!=NULL) *offset = ((coap_packet_t *)packet)->block_offset; + + return 1; +} + +int +coap_set_header_block(void *packet, uint32_t num, uint8_t more, uint16_t size) +{ + if (size<16) return 0; + if (size>2048) return 0; + if (num>0x0FFFFF) return 0; + + ((coap_packet_t *)packet)->block_num = num; + ((coap_packet_t *)packet)->block_more = more; + ((coap_packet_t *)packet)->block_size = size; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_query(void *packet, const char **query) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) return 0; + + *query = ((coap_packet_t *)packet)->uri_query; + return ((coap_packet_t *)packet)->uri_query_len; +} + +int +coap_set_header_uri_query(void *packet, char *query) +{ + while (query[0]=='?') ++query; + + ((coap_packet_t *)packet)->uri_query = query; + ((coap_packet_t *)packet)->uri_query_len = strlen(query); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY); + return ((coap_packet_t *)packet)->uri_query_len; +} +/*-----------------------------------------------------------------------------------*/ +/*- PAYLOAD -------------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +int +coap_get_payload(void *packet, const uint8_t **payload) +{ + if (((coap_packet_t *)packet)->payload) { + *payload = ((coap_packet_t *)packet)->payload; + return ((coap_packet_t *)packet)->payload_len; + } else { + *payload = NULL; + return 0; + } +} + +int +coap_set_payload(void *packet, uint8_t *payload, size_t length) +{ + PRINTF("setting payload (%u/%u)\n", length, REST_MAX_CHUNK_SIZE); + + ((coap_packet_t *)packet)->payload = payload; + ((coap_packet_t *)packet)->payload_len = MIN(REST_MAX_CHUNK_SIZE, length); + + return ((coap_packet_t *)packet)->payload_len; +} +/*-----------------------------------------------------------------------------------*/ diff --git a/apps/er-coap-03/er-coap-03.h b/apps/er-coap-03/er-coap-03.h new file mode 100644 index 000000000..169188aab --- /dev/null +++ b/apps/er-coap-03/er-coap-03.h @@ -0,0 +1,284 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * An implementation of the Constrained Application Protocol (draft 03) + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_03_H_ +#define COAP_03_H_ + +#include /* for size_t */ +#include "contiki-net.h" +#include "erbium.h" + +#define COAP_DEFAULT_PORT 61616 + +#ifndef COAP_SERVER_PORT +#define COAP_SERVER_PORT COAP_DEFAULT_PORT +#endif + +#define COAP_DEFAULT_MAX_AGE 60 +#define COAP_RESPONSE_TIMEOUT 1 +#define COAP_MAX_RETRANSMIT 5 + +#define COAP_HEADER_LEN 4 /* | oc:0xF0 type:0x0C version:0x03 | code | tid:0x00FF | tid:0xFF00 | */ +#define COAP_ETAG_LEN 4 /* The maximum number of bytes for the ETag, which is 4 for coap-03 */ +#define COAP_TOKEN_LEN 2 /* The maximum number of bytes for the ETag, which is 4 for coap-03 */ + +#define COAP_HEADER_VERSION_MASK 0xC0 +#define COAP_HEADER_VERSION_POSITION 6 +#define COAP_HEADER_TYPE_MASK 0x30 +#define COAP_HEADER_TYPE_POSITION 4 +#define COAP_HEADER_OPTION_COUNT_MASK 0x0F +#define COAP_HEADER_OPTION_COUNT_POSITION 0 + +#define COAP_HEADER_OPTION_DELTA_MASK 0xF0 +#define COAP_HEADER_OPTION_SHORT_LENGTH_MASK 0x0F + +/* + * Conservative size limit, as not all options have to be set at the same time. + */ +/* Hdr CoT Age Tag Obs Tok Blo strings */ +#define COAP_MAX_HEADER_SIZE (4 + 2 + 5 + 5 + 5 + 5 + 4 + 0) +#define COAP_MAX_PACKET_SIZE (COAP_MAX_HEADER_SIZE + REST_MAX_CHUNK_SIZE) +/* 0/14 48 for IPv6 (28 for IPv4) */ +#if COAP_MAX_PACKET_SIZE > (UIP_BUFSIZE - UIP_LLH_LEN - UIP_IPUDPH_LEN) +#error "UIP_CONF_BUFFER_SIZE too small for REST_MAX_CHUNK_SIZE" +#endif + +/* + * Maximum number of failed request attempts before action + */ +#ifndef COAP_MAX_ATTEMPTS +#define COAP_MAX_ATTEMPTS 4 +#endif /* COAP_MAX_ATTEMPTS */ + +#define UIP_IP_BUF ((struct uip_ip_hdr *)&uip_buf[UIP_LLH_LEN]) +#define UIP_UDP_BUF ((struct uip_udp_hdr *)&uip_buf[uip_l2_l3_hdr_len]) + +#define SET_OPTION(packet, opt) ((packet)->options |= 1<options & 1< + */ + +#include +#include +#include +#include "contiki.h" +#include "contiki-net.h" + +#include "er-coap-06-engine.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF(" %02x:%02x:%02x:%02x:%02x:%02x ",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#define PRINTBITS(buf,len) { \ + int i,j=0; \ + for (i=0; i=0; --j) { \ + PRINTF("%c", (((char *)buf)[i] & 1<srcipaddr); + PRINTF(":%u\n Length: %u\n Data: ", uip_ntohs(UIP_UDP_BUF->srcport), data_len ); + PRINTBITS(data, data_len); + PRINTF("\n"); + + coap_error_code = coap_parse_message(message, data, data_len); + + if (coap_error_code==NO_ERROR) + { + + /*TODO duplicates suppression, if required */ + + PRINTF(" Parsed: v %u, t %u, oc %u, c %u, tid %u\n", message->version, message->type, message->option_count, message->code, message->tid); + 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->tid, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport)) ) + { + static uint32_t block_num = 0; + static uint16_t block_size = REST_MAX_CHUNK_SIZE; + static uint32_t block_offset = 0; + static 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->tid); + } + else + { + /* Unreliable NON requests are answered with a NON as well. */ + coap_init_message(response, COAP_TYPE_NON, CONTENT_2_05, coap_get_tid()); + } + + /* resource handlers must take care of different handling (e.g., TOKEN_OPTION_REQUIRED_240) */ + if (IS_OPTION(message, COAP_OPTION_TOKEN)) + { + coap_set_header_token(response, message->token, message->token_len); + SET_OPTION(response, COAP_OPTION_TOKEN); + } + + /* 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; + } + else + { + new_offset = 0; + } + + /* 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)) + { + /* Apply blockwise transfers. */ + 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, (uint8_t*)"Block out of scope", 18); + } + 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) */ + } + } + else + { + coap_error_code = INTERNAL_SERVER_ERROR_5_00; + coap_error_message = "Service callback undefined"; + } /* if (service callback) */ + + /* serialize Response. */ + if ((transaction->packet_len = coap_serialize_message(response, transaction->packet))==0) + { + coap_error_code = PACKET_SERIALIZATION_ERROR; + } + + } else { + coap_error_code = MEMORY_ALLOC_ERR; + coap_error_message = "Transaction buffer allocation failed"; + } /* if (transaction buffer) */ + } + else + { + /* Responses */ + + if (message->type==COAP_TYPE_ACK) + { + PRINTF("Received ACK\n"); + } + else if (message->type==COAP_TYPE_RST) + { + PRINTF("Received RST\n"); + /* Cancel possible subscriptions. */ + if (IS_OPTION(message, COAP_OPTION_TOKEN)) + { + PRINTF(" Token 0x%02X%02X\n", message->token[0], message->token[1]); + coap_remove_observer_by_token(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, message->token, message->token_len); + } + } + + if ( (transaction = coap_get_transaction_by_tid(message->tid)) ) + { + /* 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; + } + } /* if (parsed correctly) */ + + if (coap_error_code==NO_ERROR) { + if (transaction) coap_send_transaction(transaction); + } + else + { + 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; + } + /* Reuse input buffer for error message. */ + coap_init_message(message, COAP_TYPE_ACK, coap_error_code, message->tid); + coap_set_payload(message, (uint8_t *) coap_error_message, strlen(coap_error_message)); + coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, data, coap_serialize_message(message, data)); + } + } /* if (new data) */ + + return coap_error_code; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_receiver_init() +{ + process_start(&coap_receiver, NULL); +} +/*-----------------------------------------------------------------------------------*/ +void +coap_set_service_callback(service_callback_t callback) +{ + service_cbk = callback; +} +/*-----------------------------------------------------------------------------------*/ +rest_resource_flags_t +coap_get_rest_method(void *packet) +{ + return (rest_resource_flags_t)(1 << (((coap_packet_t *)packet)->code - 1)); +} +/*-----------------------------------------------------------------------------------*/ +int +coap_set_rest_status(void *packet, unsigned int code) +{ + if (code <= 0xFF) + { + ((coap_packet_t *)packet)->code = (uint8_t) code; + return 1; + } + else + { + return 0; + } +} +/*-----------------------------------------------------------------------------------*/ +/*- Server part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +/* The discover resource is automatically included for CoAP. */ +RESOURCE(well_known_core, METHOD_GET, ".well-known/core", ""); +void +well_known_core_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + /* Response might be NULL for non-confirmable requests. */ + if (response) + { + size_t strpos = 0; + size_t bufpos = 0; + resource_t* resource = NULL; + + for (resource = (resource_t*)list_head(rest_get_resources()); resource; resource = resource->next) + { + strpos += snprintf((char *) buffer + bufpos, REST_MAX_CHUNK_SIZE - bufpos + 1, + "%s%s%s", + resource->url, + resource->attributes[0] ? ";" : "", + resource->attributes, + resource->next ? "," : "" ); + + PRINTF("discover: %s\n", resource->url); + + if (strpos <= *offset) + { + /* Discard output before current block */ + PRINTF(" if %d <= %ld B\n", strpos, *offset); + PRINTF(" %s\n", buffer); + bufpos = 0; + } + else /* (strpos > *offset) */ + { + /* output partly in block */ + size_t len = MIN(strpos - *offset, preferred_size); + + PRINTF(" el %d/%d @ %ld B\n", len, preferred_size, *offset); + + /* Block might start in the middle of the output; align with buffer start. */ + if (bufpos == 0) + { + memmove(buffer, buffer+strlen((char *)buffer)-strpos+*offset, len); + } + + bufpos = len; + PRINTF(" %s\n", buffer); + + if (bufpos >= preferred_size) + { + break; + } + } + } + + if (bufpos>0) { + coap_set_payload(response, buffer, bufpos ); + coap_set_header_content_type(response, APPLICATION_LINK_FORMAT); + } + else + { + PRINTF("well_known_core_handler(): bufpos<=0\n"); + + coap_set_rest_status(response, BAD_OPTION_4_02); + coap_set_payload(response, (uint8_t*)"Block out of scope", 18); + } + + if (resource==NULL) { + *offset = -1; + } + else + { + *offset += bufpos; + } + } +} +/*-----------------------------------------------------------------------------------*/ +PROCESS_THREAD(coap_receiver, ev, data) +{ + PROCESS_BEGIN(); + PRINTF("Starting CoAP-06 receiver...\n"); + + rest_activate_resource(&resource_well_known_core); + + coap_register_as_transaction_handler(); + coap_init_connection(SERVER_LISTEN_PORT); + + while(1) { + PROCESS_YIELD(); + + if(ev == tcpip_event) { + handle_incoming_data(); + } else if (ev == PROCESS_EVENT_TIMER) { + /* retransmissions are handled here */ + coap_check_transactions(); + } + } /* while (1) */ + + PROCESS_END(); +} +/*-----------------------------------------------------------------------------------*/ +/*- Client part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void blocking_request_callback(void *callback_data, void *response) { + struct request_state_t *state = (struct request_state_t *) callback_data; + state->response = (coap_packet_t*) response; + process_poll(state->process); +} +/*-----------------------------------------------------------------------------------*/ +PT_THREAD(coap_blocking_request(struct request_state_t *state, process_event_t ev, + uip_ipaddr_t *remote_ipaddr, uint16_t remote_port, + coap_packet_t *request, + blocking_response_handler request_callback)) { + PT_BEGIN(&state->pt); + + static uint8_t more; + static uint32_t res_block; + static uint8_t block_error; + + state->block_num = 0; + state->response = NULL; + state->process = PROCESS_CURRENT(); + + more = 0; + res_block = 0; + block_error = 0; + + do { + request->tid = coap_get_tid(); + if ((state->transaction = coap_new_transaction(request->tid, remote_ipaddr, remote_port))) + { + state->transaction->callback = blocking_request_callback; + state->transaction->callback_data = state; + + if (state->block_num>0) + { + coap_set_header_block2(request, state->block_num, 0, REST_MAX_CHUNK_SIZE); + } + + state->transaction->packet_len = coap_serialize_message(request, state->transaction->packet); + + coap_send_transaction(state->transaction); + PRINTF("Requested #%lu (TID %u)\n", state->block_num, request->tid); + + PT_YIELD_UNTIL(&state->pt, ev == PROCESS_EVENT_POLL); + + if (!state->response) + { + PRINTF("Server not responding\n"); + PT_EXIT(&state->pt); + } + + coap_get_header_block2(state->response, &res_block, &more, NULL, NULL); + + PRINTF("Received #%lu%s (%u bytes)\n", res_block, more ? "+" : "", state->response->payload_len); + + if (res_block==state->block_num) + { + request_callback(state->response); + ++(state->block_num); + } + else + { + PRINTF("WRONG BLOCK %lu/%lu\n", res_block, state->block_num); + ++block_error; + } + } + else + { + PRINTF("Could not allocate transaction buffer"); + PT_EXIT(&state->pt); + } + } while (more && block_errorpt); +} +/*-----------------------------------------------------------------------------------*/ +/*- Engine Interface ----------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +const struct rest_implementation coap_rest_implementation = { + "CoAP-06", + + coap_receiver_init, + coap_set_service_callback, + + coap_get_header_uri_path, + coap_set_header_uri_path, + coap_get_rest_method, + coap_set_rest_status, + + coap_get_header_content_type, + coap_set_header_content_type, + NULL, + coap_get_header_max_age, + coap_set_header_max_age, + coap_set_header_etag, + NULL, + NULL, + coap_get_header_uri_host, + coap_set_header_location_path, + + coap_get_payload, + coap_set_payload, + + coap_get_header_uri_query, + coap_get_query_variable, + coap_get_post_variable, + + coap_notify_observers, + (restful_post_handler) coap_observe_handler, + + NULL, /* default pre-handler (set separate handler after activation if needed) */ + NULL, /* default post-handler for non-observable resources */ + + { + CONTENT_2_05, + CREATED_2_01, + CHANGED_2_04, + DELETED_2_02, + VALID_2_03, + BAD_REQUEST_4_00, + UNAUTHORIZED_4_01, + BAD_OPTION_4_02, + FORBIDDEN_4_03, + NOT_FOUND_4_04, + METHOD_NOT_ALLOWED_4_05, + REQUEST_ENTITY_TOO_LARGE_4_13, + UNSUPPORTED_MADIA_TYPE_4_15, + INTERNAL_SERVER_ERROR_5_00, + NOT_IMPLEMENTED_5_01, + BAD_GATEWAY_5_02, + SERVICE_UNAVAILABLE_5_03, + GATEWAY_TIMEOUT_5_04, + PROXYING_NOT_SUPPORTED_5_05 + }, + + { + TEXT_PLAIN, + TEXT_XML, + TEXT_CSV, + TEXT_HTML, + IMAGE_GIF, + IMAGE_JPEG, + IMAGE_PNG, + IMAGE_TIFF, + AUDIO_RAW, + VIDEO_RAW, + APPLICATION_LINK_FORMAT, + APPLICATION_XML, + APPLICATION_OCTET_STREAM, + APPLICATION_RDF_XML, + APPLICATION_SOAP_XML, + APPLICATION_ATOM_XML, + APPLICATION_XMPP_XML, + APPLICATION_EXI, + APPLICATION_FASTINFOSET, + APPLICATION_SOAP_FASTINFOSET, + APPLICATION_JSON, + APPLICATION_X_OBIX_BINARY + } +}; diff --git a/apps/er-coap-06/er-coap-06-engine.h b/apps/er-coap-06/er-coap-06-engine.h new file mode 100644 index 000000000..c8c907d40 --- /dev/null +++ b/apps/er-coap-06/er-coap-06-engine.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP implementation of the REST Engine + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_SERVER_H_ +#define COAP_SERVER_H_ + +#if !defined(REST) +#error "Define REST to \"coap_rest_implementation\"" +#endif + +#include "er-coap-06.h" +#include "er-coap-06-transactions.h" +#include "er-coap-06-observing.h" +#include "er-coap-06-separate.h" + +#include "pt.h" + +/* Declare server process */ +PROCESS_NAME(coap_receiver); + +#define SERVER_LISTEN_PORT UIP_HTONS(COAP_SERVER_PORT) + +typedef coap_packet_t rest_request_t; +typedef coap_packet_t rest_response_t; + +extern const struct rest_implementation coap_rest_implementation; + +void coap_receiver_init(void); + +/*-----------------------------------------------------------------------------------*/ +/*- Client part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +struct request_state_t { + struct pt pt; + struct process *process; + coap_transaction_t *transaction; + coap_packet_t *response; + uint32_t block_num; +}; + +typedef void (*blocking_response_handler) (void* response); + +PT_THREAD(coap_blocking_request(struct request_state_t *state, process_event_t ev, + uip_ipaddr_t *remote_ipaddr, uint16_t remote_port, + coap_packet_t *request, + blocking_response_handler request_callback)); + +#define COAP_BLOCKING_REQUEST(server_addr, server_port, request, chunk_handler) \ +static struct request_state_t request_state; \ +PT_SPAWN(process_pt, &request_state.pt, \ + coap_blocking_request(&request_state, ev, \ + server_addr, server_port, \ + request, chunk_handler) \ + ); +/*-----------------------------------------------------------------------------------*/ + +#endif /* COAP_SERVER_H_ */ diff --git a/apps/er-coap-06/er-coap-06-observing.c b/apps/er-coap-06/er-coap-06-observing.c new file mode 100644 index 000000000..43f5fff49 --- /dev/null +++ b/apps/er-coap-06/er-coap-06-observing.c @@ -0,0 +1,201 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for observing resources + * \author + * Matthias Kovatsch + */ + +#include +#include + +#include "er-coap-06-observing.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +MEMB(observers_memb, coap_observer_t, COAP_MAX_OBSERVERS); +LIST(observers_list); + +/*-----------------------------------------------------------------------------------*/ +coap_observer_t * +coap_add_observer(const char *url, uip_ipaddr_t *addr, uint16_t port, const uint8_t *token, size_t token_len) +{ + coap_observer_t *o = memb_alloc(&observers_memb); + + if (o) + { + o->url = url; + uip_ipaddr_copy(&o->addr, addr); + o->port = port; + o->token_len = token_len; + memcpy(o->token, token, token_len); + + stimer_set(&o->refresh_timer, COAP_OBSERVING_REFRESH_INTERVAL); + + PRINTF("Adding observer for /%s [0x%02X%02X]\n", o->url, o->token[0], o->token[1]); + list_add(observers_list, o); + } + + return o; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_remove_observer(coap_observer_t *o) +{ + PRINTF("Removing observer for /%s [0x%02X%02X]\n", o->url, o->token[0], o->token[1]); + + memb_free(&observers_memb, o); + list_remove(observers_list, o); +} + +int +coap_remove_observer_by_client(uip_ipaddr_t *addr, uint16_t port) +{ + int removed = 0; + coap_observer_t* obs = NULL; + + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + PRINTF("Remove check client "); + PRINT6ADDR(addr); + PRINTF(":%u\n", port); + if (uip_ipaddr_cmp(&obs->addr, addr) && obs->port==port) + { + coap_remove_observer(obs); + removed++; + } + } + return removed; +} +int +coap_remove_observer_by_token(uip_ipaddr_t *addr, uint16_t port, uint8_t *token, size_t token_len) +{ + int removed = 0; + coap_observer_t* obs = NULL; + + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + PRINTF("Remove check Token 0x%02X%02X\n", token[0], token[1]); + if (uip_ipaddr_cmp(&obs->addr, addr) && obs->port==port && memcmp(obs->token, token, token_len)==0) + { + coap_remove_observer(obs); + removed++; + } + } + return removed; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_notify_observers(const char *url, int type, uint32_t observe, uint8_t *payload, size_t payload_len) +{ + coap_observer_t* obs = NULL; + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + if (obs->url==url) /* using RESOURCE url pointer as handle */ + { + coap_transaction_t *transaction = NULL; + + /*TODO implement special transaction for CON, sharing the same buffer to allow for more observers */ + + if ( (transaction = coap_new_transaction(coap_get_tid(), &obs->addr, obs->port)) ) + { + /* Use CON to check whether client is still there/interested after COAP_OBSERVING_REFRESH_INTERVAL. */ + if (stimer_expired(&obs->refresh_timer)) + { + PRINTF("Observing: Refresh client with CON\n"); + type = COAP_TYPE_CON; + stimer_restart(&obs->refresh_timer); + } + + /* prepare response */ + coap_packet_t push[1]; /* This way the packet can be treated as pointer as usual. */ + coap_init_message(push, (coap_message_type_t)type, CONTENT_2_05, transaction->tid ); + coap_set_header_observe(push, observe); + coap_set_header_token(push, obs->token, obs->token_len); + coap_set_payload(push, payload, payload_len); + transaction->packet_len = coap_serialize_message(push, transaction->packet); + + PRINTF("Observing: Notify from /%s for ", url); + PRINT6ADDR(&obs->addr); + PRINTF(":%u\n", obs->port); + PRINTF(" %.*s\n", payload_len, payload); + + coap_send_transaction(transaction); + } + } + } +} +/*-----------------------------------------------------------------------------------*/ +void +coap_observe_handler(resource_t *resource, void *request, void *response) +{ + static char content[26]; + + if (response && ((coap_packet_t *)response)->code<128) /* response without error code */ + { + if (IS_OPTION((coap_packet_t *)request, COAP_OPTION_OBSERVE)) + { + if (!IS_OPTION((coap_packet_t *)request, COAP_OPTION_TOKEN)) + { + /* Set default token. */ + coap_set_header_token(request, (uint8_t *)"", 1); + } + + if (coap_add_observer(resource->url, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, ((coap_packet_t *)request)->token, ((coap_packet_t *)request)->token_len)) + { + coap_set_header_observe(response, 0); + coap_set_payload(response, (uint8_t *)content, snprintf(content, sizeof(content), "Added as observer %u/%u", list_length(observers_list), COAP_MAX_OBSERVERS)); + } + else + { + ((coap_packet_t *)response)->code = SERVICE_UNAVAILABLE_5_03; + coap_set_payload(response, (uint8_t *)"Too many observers", 18); + } /* if (added observer) */ + } + else /* if (observe) */ + { + /* Remove client if it is currently observing. */ + coap_remove_observer_by_client(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport); + } /* if (observe) */ + } +} diff --git a/apps/er-coap-06/er-coap-06-observing.h b/apps/er-coap-06/er-coap-06-observing.h new file mode 100644 index 000000000..b3f266dd0 --- /dev/null +++ b/apps/er-coap-06/er-coap-06-observing.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for observing resources + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_OBSERVING_H_ +#define COAP_OBSERVING_H_ + +#include "er-coap-06.h" +#include "er-coap-06-transactions.h" + +#ifndef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS 4 +#endif /* COAP_MAX_OBSERVERS */ + +/* Interval in seconds in which NON notifies are changed to CON notifies to check client. */ +#define COAP_OBSERVING_REFRESH_INTERVAL 60 + +#if COAP_MAX_OPEN_TRANSACTIONS + */ + +#include +#include + +#include "er-coap-06-separate.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +/*-----------------------------------------------------------------------------------*/ +void coap_separate_handler(resource_t *resource, void *request, void *response) +{ + if (resource->benchmark > COAP_SEPARATE_THRESHOLD) + { + PRINTF("Separate response for /%s \n", resource->url); + /* send separate ACK. */ + coap_packet_t ack[1]; + /* ACK with empty code (0) */ + coap_init_message(ack, COAP_TYPE_ACK, 0, ((coap_packet_t *)request)->tid); + /* Should only overwrite Header which is already parsed to request. */ + coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, (uip_appdata + uip_ext_len), coap_serialize_message(ack, (uip_appdata + uip_ext_len))); + + /* Change response to separate response. */ + ((coap_packet_t *)response)->type = COAP_TYPE_CON; + ((coap_packet_t *)response)->tid = coap_get_tid(); + } +} diff --git a/apps/er-coap-06/er-coap-06-separate.h b/apps/er-coap-06/er-coap-06-separate.h new file mode 100644 index 000000000..079384f0c --- /dev/null +++ b/apps/er-coap-06/er-coap-06-separate.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for separate responses + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_SEPARATE_H_ +#define COAP_SEPARATE_H_ + +#include "er-coap-06.h" + +#ifndef COAP_SEPARATE_THRESHOLD +#define COAP_SEPARATE_THRESHOLD 42 +#endif + +void coap_separate_handler(resource_t *resource, void *request, void *response); + +#endif /* COAP_SEPARATE_H_ */ diff --git a/apps/er-coap-06/er-coap-06-transactions.c b/apps/er-coap-06/er-coap-06-transactions.c new file mode 100644 index 000000000..980fad7f3 --- /dev/null +++ b/apps/er-coap-06/er-coap-06-transactions.c @@ -0,0 +1,194 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for reliable transport + * \author + * Matthias Kovatsch + */ + +#include "contiki.h" +#include "contiki-net.h" + +#include "er-coap-06-transactions.h" + +/* + * Modulo mask (+1 and +0.5 for rounding) for a random number to get the tick number for the random + * retransmission time between COAP_RESPONSE_TIMEOUT and COAP_RESPONSE_TIMEOUT*COAP_RESPONSE_RANDOM_FACTOR. + */ +#define COAP_RESPONSE_TIMEOUT_TICKS (CLOCK_SECOND * COAP_RESPONSE_TIMEOUT) +#define COAP_RESPONSE_TIMEOUT_BACKOFF_MASK ((CLOCK_SECOND * COAP_RESPONSE_TIMEOUT * (COAP_RESPONSE_RANDOM_FACTOR - 1)) + 1.5) + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +MEMB(transactions_memb, coap_transaction_t, COAP_MAX_OPEN_TRANSACTIONS); +LIST(transactions_list); + + +static struct process *transaction_handler_process = NULL; + +void +coap_register_as_transaction_handler() +{ + transaction_handler_process = PROCESS_CURRENT(); +} + +coap_transaction_t * +coap_new_transaction(uint16_t tid, uip_ipaddr_t *addr, uint16_t port) +{ + coap_transaction_t *t = memb_alloc(&transactions_memb); + + if (t) + { + t->tid = tid; + t->retrans_counter = 0; + + /* save client address */ + uip_ipaddr_copy(&t->addr, addr); + t->port = port; + } + + return t; +} + +void +coap_send_transaction(coap_transaction_t *t) +{ + PRINTF("Sending transaction %u\n", t->tid); + + coap_send_message(&t->addr, t->port, t->packet, t->packet_len); + + if (COAP_TYPE_CON==((COAP_HEADER_TYPE_MASK & t->packet[0])>>COAP_HEADER_TYPE_POSITION)) + { + if (t->retrans_countertid); + + if (t->retrans_counter==0) + { + t->retrans_timer.timer.interval = COAP_RESPONSE_TIMEOUT_TICKS + (random_rand() % (clock_time_t) COAP_RESPONSE_TIMEOUT_BACKOFF_MASK); + PRINTF("Initial interval %f\n", (float)t->retrans_timer.timer.interval/CLOCK_SECOND); + } + else + { + t->retrans_timer.timer.interval <<= 1; /* double */ + PRINTF("Doubled (%u) interval %f\n", t->retrans_counter, (float)t->retrans_timer.timer.interval/CLOCK_SECOND); + } + + /*FIXME hack, maybe there is a better way, but avoid posting everything to the process */ + struct process *process_actual = PROCESS_CURRENT(); + process_current = transaction_handler_process; + etimer_restart(&t->retrans_timer); /* interval updated above */ + process_current = process_actual; + + list_add(transactions_list, t); /* List itself makes sure same element is not added twice. */ + + t = NULL; + } + else + { + /* timeout */ + PRINTF("Timeout\n"); + restful_response_handler callback = t->callback; + void *callback_data = t->callback_data; + + /* handle observers */ + coap_remove_observer_by_client(&t->addr, t->port); + + coap_clear_transaction(t); + + if (callback) { + callback(callback_data, NULL); + } + } + } + else + { + coap_clear_transaction(t); + } +} + +void +coap_clear_transaction(coap_transaction_t *t) +{ + if (t) + { + PRINTF("Freeing transaction %u: %p\n", t->tid, t); + + etimer_stop(&t->retrans_timer); + list_remove(transactions_list, t); + memb_free(&transactions_memb, t); + } +} + +coap_transaction_t * +coap_get_transaction_by_tid(uint16_t tid) +{ + coap_transaction_t *t = NULL; + + for (t = (coap_transaction_t*)list_head(transactions_list); t; t = t->next) + { + if (t->tid==tid) + { + PRINTF("Found transaction for TID %u: %p\n", t->tid, t); + return t; + } + } + return NULL; +} + +void +coap_check_transactions() +{ + coap_transaction_t *t = NULL; + + for (t = (coap_transaction_t*)list_head(transactions_list); t; t = t->next) + { + if (etimer_expired(&t->retrans_timer)) + { + ++(t->retrans_counter); + PRINTF("Retransmitting %u (%u)\n", t->tid, t->retrans_counter); + coap_send_transaction(t); + } + } +} diff --git a/apps/er-coap-06/er-coap-06-transactions.h b/apps/er-coap-06/er-coap-06-transactions.h new file mode 100644 index 000000000..f5e97454f --- /dev/null +++ b/apps/er-coap-06/er-coap-06-transactions.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for reliable transport + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_TRANSACTIONS_H_ +#define COAP_TRANSACTIONS_H_ + +#include "er-coap-06.h" +#include "er-coap-06-observing.h" + +/* + * The number of concurrent messages that can be stored for retransmission in the transaction layer. + */ +#ifndef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 4 +#endif /* COAP_MAX_OPEN_TRANSACTIONS */ + +/* container for transactions with message buffer and retransmission info */ +typedef struct coap_transaction { + struct coap_transaction *next; /* for LIST */ + + uint16_t tid; + struct etimer retrans_timer; + uint8_t retrans_counter; + + uip_ipaddr_t addr; + uint16_t port; + + restful_response_handler callback; + void *callback_data; + + uint16_t packet_len; + uint8_t packet[COAP_MAX_PACKET_SIZE+1]; /* +1 for the terminating '\0' to simply and savely use snprintf(buf, len+1, "", ...) in the resource handler. */ +} coap_transaction_t; + +void coap_register_as_transaction_handler(); + +coap_transaction_t *coap_new_transaction(uint16_t tid, uip_ipaddr_t *addr, uint16_t port); +void coap_send_transaction(coap_transaction_t *t); +void coap_clear_transaction(coap_transaction_t *t); +coap_transaction_t *coap_get_transaction_by_tid(uint16_t tid); + +void coap_check_transactions(); + +#endif /* COAP_TRANSACTIONS_H_ */ diff --git a/apps/er-coap-06/er-coap-06.c b/apps/er-coap-06/er-coap-06.c new file mode 100644 index 000000000..3e72c48e7 --- /dev/null +++ b/apps/er-coap-06/er-coap-06.c @@ -0,0 +1,986 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * An implementation of the Constrained Application Protocol (draft 06) + * \author + * Matthias Kovatsch + */ + +#include "contiki.h" +#include "contiki-net.h" +#include +#include + +#include "er-coap-06.h" +#include "er-coap-06-transactions.h" + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +/*-----------------------------------------------------------------------------------*/ +/*- Variables -----------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +static struct uip_udp_conn *udp_conn = NULL; +static uint16_t current_tid = 0; + +coap_status_t coap_error_code = NO_ERROR; +char *coap_error_message = ""; +/*-----------------------------------------------------------------------------------*/ +/*- LOCAL HELP FUNCTIONS ------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +static +uint16_t +log_2(uint16_t value) +{ + uint16_t result = 0; + do { + value = value >> 1; + result++; + } while (value); + + return result ? result - 1 : result; +} +/*-----------------------------------------------------------------------------------*/ +static +uint32_t +parse_int_option(uint8_t *bytes, uint16_t length) +{ + uint32_t var = 0; + int i = 0; + while (i 15) + { + uint8_t delta = COAP_OPTION_FENCE_POST - (*current_number%COAP_OPTION_FENCE_POST); + set_option_header(delta, 0, &buffer[i++]); + *current_number += delta; + + PRINTF("OPTION FENCE POST delta %u\n", delta); + } + return i; +} +/*-----------------------------------------------------------------------------------*/ +static +size_t +serialize_int_option(int number, int current_number, uint8_t *buffer, uint32_t value) +{ + /* Insert fence-posts for large deltas */ + size_t i = insert_option_fence_posts(number, ¤t_number, buffer); + size_t start_i = i; + + uint8_t *option = &buffer[i]; + + if (0xFF000000 & value) buffer[++i] = (uint8_t) (value>>24); + if (0x00FF0000 & value) buffer[++i] = (uint8_t) (value>>16); + if (0x0000FF00 & value) buffer[++i] = (uint8_t) (value>>8); + if (0x000000FF & value) buffer[++i] = (uint8_t) value; + + i += set_option_header(number - current_number, i-start_i, option); + + PRINTF("OPTION type %u, delta %u, len %u\n", number, number - current_number, i-start_i); + + return i; +} +/*-----------------------------------------------------------------------------------*/ +static +size_t +serialize_array_option(int number, int current_number, uint8_t *buffer, uint8_t *array, size_t length, uint8_t *split_option) +{ + /* Insert fence-posts for large deltas */ + size_t i = insert_option_fence_posts(number, ¤t_number, buffer); + + if (split_option!=NULL) + { + int j; + uint8_t *part_start = array; + uint8_t *part_end = NULL; + size_t temp_length; + + char split_char = *split_option; + *split_option = 0; /* Ensure reflecting the created option count */ + + for (j = 0; j<=length; ++j) + { + if (array[j]==split_char || j==length) + { + part_end = array + j; + temp_length = part_end-part_start; + + i += set_option_header(number - current_number, temp_length, &buffer[i]); + memcpy(&buffer[i], part_start, temp_length); + i += temp_length; + + PRINTF("OPTION type %u, delta %u, len %u, part [%.*s]\n", number, number - current_number, i, temp_length, part_start); + + ++(*split_option); + ++j; /* skip the slash */ + current_number = number; + while( array[j]=='/') ++j; + part_start = array + j; + } + } /* for */ + } + else + { + i += set_option_header(number - current_number, length, &buffer[i]); + memcpy(&buffer[i], array, length); + i += length; + + PRINTF("OPTION type %u, delta %u, len %u\n", number, number - current_number, i); + } + + return i; +} +/*-----------------------------------------------------------------------------------*/ +static +void +coap_merge_multi_option(char **dst, size_t *dst_len, uint8_t *option, size_t option_len, char separator) +{ + /* Merge multiple options. */ + if (*dst_len > 0) + { + (*dst)[*dst_len] = separator; + *dst_len += 1; + + /* memmove handles 2-byte option headers */ + memmove((*dst)+(*dst_len), option, option_len); + + *dst_len += option_len; + } + else + { + *dst = (char *) option; /* thus pointer pointer */ + *dst_len = option_len; + } +} +/*-----------------------------------------------------------------------------------*/ +static +int +coap_get_variable(const char *buffer, size_t length, const char *name, const char **output) +{ + const char *start = NULL; + const char *end = NULL; + const char *value_end = NULL; + size_t name_len = 0; + + /*initialize the output buffer first*/ + *output = 0; + + name_len = strlen(name); + end = buffer + length; + + for (start = buffer; start + name_len < end; ++start){ + if ((start == buffer || start[-1] == '&') && start[name_len] == '=' && + strncmp(name, start, name_len)==0) { + + /* Point start to variable value */ + start += name_len + 1; + + /* Point end to the end of the value */ + value_end = (const char *) memchr(start, '&', end - start); + if (value_end == NULL) { + value_end = end; + } + + *output = start; + + return (value_end - start); + } + } + + return 0; +} +/*-----------------------------------------------------------------------------------*/ +/*- MEASSAGE SENDING ----------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void +coap_init_connection(uint16_t port) +{ + /* new connection with remote host */ + udp_conn = udp_new(NULL, 0, NULL); + udp_bind(udp_conn, port); + PRINTF("Listening on port %u\n", uip_ntohs(udp_conn->lport)); + + /* Initialize transaction ID. */ + current_tid = random_rand(); +} +/*-----------------------------------------------------------------------------------*/ +uint16_t +coap_get_tid() +{ + return ++current_tid; +} +/*-----------------------------------------------------------------------------------*/ +/*- MEASSAGE PROCESSING -------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void +coap_init_message(void *packet, coap_message_type_t type, uint8_t code, uint16_t tid) +{ + /* Important thing */ + memset(packet, 0, sizeof(coap_packet_t)); + + ((coap_packet_t *)packet)->type = type; + ((coap_packet_t *)packet)->code = code; + ((coap_packet_t *)packet)->tid = tid; +} +/*-----------------------------------------------------------------------------------*/ +size_t +coap_serialize_message(void *packet, uint8_t *buffer) +{ + /* Initialize */ + ((coap_packet_t *)packet)->buffer = buffer; + ((coap_packet_t *)packet)->version = 1; + ((coap_packet_t *)packet)->option_count = 0; + + /* serialize options */ + uint8_t *option = ((coap_packet_t *)packet)->buffer + COAP_HEADER_LEN; + int current_number = 0; + + PRINTF("-Serializing options-\n"); + + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE)) { + PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type); + + option += serialize_int_option(COAP_OPTION_CONTENT_TYPE, current_number, option, ((coap_packet_t *)packet)->content_type); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_CONTENT_TYPE; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) { + PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age); + + option += serialize_int_option(COAP_OPTION_MAX_AGE, current_number, option, ((coap_packet_t *)packet)->max_age); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_MAX_AGE; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI)) { + PRINTF("Proxy-Uri [%.*s]\n", ((coap_packet_t *)packet)->proxy_uri_len, ((coap_packet_t *)packet)->proxy_uri); + + int length = ((coap_packet_t *)packet)->proxy_uri_len; + int j = 0; + while (length>0) + { + option += serialize_array_option(COAP_OPTION_PROXY_URI, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->proxy_uri + j*270, MIN(270, length), NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_PROXY_URI; + + ++j; + length -= 270; + } + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) { + PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->etag_len, + ((coap_packet_t *)packet)->etag[0], + ((coap_packet_t *)packet)->etag[1], + ((coap_packet_t *)packet)->etag[2], + ((coap_packet_t *)packet)->etag[3], + ((coap_packet_t *)packet)->etag[4], + ((coap_packet_t *)packet)->etag[5], + ((coap_packet_t *)packet)->etag[6], + ((coap_packet_t *)packet)->etag[7] + ); /*FIXME always prints 8 bytes */ + + option += serialize_array_option(COAP_OPTION_ETAG, current_number, option, ((coap_packet_t *)packet)->etag, ((coap_packet_t *)packet)->etag_len, NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_ETAG; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) { + PRINTF("Uri-Host [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host); + + option += serialize_array_option(COAP_OPTION_URI_HOST, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_host, ((coap_packet_t *)packet)->uri_host_len, NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_URI_HOST; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) { + PRINTF("Location [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path); + + uint8_t split_options = '/'; + + option += serialize_array_option(COAP_OPTION_LOCATION_PATH, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->location_path, ((coap_packet_t *)packet)->location_path_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options; + current_number = COAP_OPTION_LOCATION_PATH; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PORT)) { + PRINTF("Uri-Port [%u]\n", ((coap_packet_t *)packet)->uri_port); + + option += serialize_int_option(COAP_OPTION_URI_PORT, current_number, option, ((coap_packet_t *)packet)->uri_port); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_URI_PORT; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY)) { + PRINTF("Location-Query [%.*s]\n", ((coap_packet_t *)packet)->location_query_len, ((coap_packet_t *)packet)->location_query); + + uint8_t split_options = '&'; + + option += serialize_array_option(COAP_OPTION_LOCATION_QUERY, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->location_query, ((coap_packet_t *)packet)->location_query_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options; + current_number = COAP_OPTION_LOCATION_QUERY; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) { + PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path); + + uint8_t split_options = '/'; + + option += serialize_array_option(COAP_OPTION_URI_PATH, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_path, ((coap_packet_t *)packet)->uri_path_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options; + current_number = COAP_OPTION_URI_PATH; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) { + PRINTF("Observe [%u]\n", ((coap_packet_t *)packet)->observe); + + option += serialize_int_option(COAP_OPTION_OBSERVE, current_number, option, ((coap_packet_t *)packet)->observe); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_OBSERVE; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) { + PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->token_len, + ((coap_packet_t *)packet)->token[0], + ((coap_packet_t *)packet)->token[1], + ((coap_packet_t *)packet)->token[2], + ((coap_packet_t *)packet)->token[3], + ((coap_packet_t *)packet)->token[4], + ((coap_packet_t *)packet)->token[5], + ((coap_packet_t *)packet)->token[6], + ((coap_packet_t *)packet)->token[7] + ); /*FIXME always prints 8 bytes */ + + option += serialize_array_option(COAP_OPTION_TOKEN, current_number, option, ((coap_packet_t *)packet)->token, ((coap_packet_t *)packet)->token_len, NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_TOKEN; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) { + PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query); + + uint8_t split_options = '&'; + + option += serialize_array_option(COAP_OPTION_URI_QUERY, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options + (COAP_OPTION_URI_QUERY-current_number)/COAP_OPTION_FENCE_POST; + current_number = COAP_OPTION_URI_QUERY; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2)) + { + PRINTF("Block2 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block2_num, ((coap_packet_t *)packet)->block2_more ? "+" : "", ((coap_packet_t *)packet)->block2_size); + + uint32_t block = ((coap_packet_t *)packet)->block2_num << 4; + if (((coap_packet_t *)packet)->block2_more) block |= 0x8; + block |= 0xF & log_2(((coap_packet_t *)packet)->block2_size/16); + + PRINTF("Block2 encoded: 0x%lX\n", block); + + option += serialize_int_option(COAP_OPTION_BLOCK2, current_number, option, block); + + ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_BLOCK2-current_number)/COAP_OPTION_FENCE_POST; + current_number = COAP_OPTION_BLOCK2; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1)) + { + PRINTF("Block1 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block1_num, ((coap_packet_t *)packet)->block1_more ? "+" : "", ((coap_packet_t *)packet)->block1_size); + + uint32_t block = ((coap_packet_t *)packet)->block1_num << 4; + if (((coap_packet_t *)packet)->block1_more) block |= 0x8; + block |= 0xF & log_2(((coap_packet_t *)packet)->block1_size/16); + + PRINTF("Block1 encoded: 0x%lX\n", block); + + option += serialize_int_option(COAP_OPTION_BLOCK1, current_number, option, block); + + ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_BLOCK1-current_number)/COAP_OPTION_FENCE_POST; + current_number = COAP_OPTION_BLOCK1; + } + + /* pack payload */ + if ((option - ((coap_packet_t *)packet)->buffer)<=COAP_MAX_HEADER_SIZE) + { + memmove(option, ((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len); + } + else + { + /* An error occured. Caller must check for !=0. */ + ((coap_packet_t *)packet)->buffer = NULL; + coap_error_message = "Serialized header exceeds COAP_MAX_HEADER_SIZE"; + return 0; + } + + /* set header fields */ + ((coap_packet_t *)packet)->buffer[0] = 0x00; + ((coap_packet_t *)packet)->buffer[0] |= COAP_HEADER_VERSION_MASK & (((coap_packet_t *)packet)->version)<buffer[0] |= COAP_HEADER_TYPE_MASK & (((coap_packet_t *)packet)->type)<buffer[0] |= COAP_HEADER_OPTION_COUNT_MASK & (((coap_packet_t *)packet)->option_count)<buffer[1] = ((coap_packet_t *)packet)->code; + ((coap_packet_t *)packet)->buffer[2] = 0xFF & (((coap_packet_t *)packet)->tid)>>8; + ((coap_packet_t *)packet)->buffer[3] = 0xFF & ((coap_packet_t *)packet)->tid; + + PRINTF("-Done %u options, header len %u, payload len %u-\n", ((coap_packet_t *)packet)->option_count, option - buffer, ((coap_packet_t *)packet)->payload_len); + + return (option - buffer) + ((coap_packet_t *)packet)->payload_len; /* packet length */ +} +/*-----------------------------------------------------------------------------------*/ +void +coap_send_message(uip_ipaddr_t *addr, uint16_t port, uint8_t *data, uint16_t length) +{ + /*configure connection to reply to client*/ + uip_ipaddr_copy(&udp_conn->ripaddr, addr); + udp_conn->rport = port; + + uip_udp_packet_send(udp_conn, data, length); + PRINTF("-sent UDP datagram (%u)-\n", length); + + /* Restore server connection to allow data from any node */ + memset(&udp_conn->ripaddr, 0, sizeof(udp_conn->ripaddr)); + udp_conn->rport = 0; +} +/*-----------------------------------------------------------------------------------*/ +coap_status_t +coap_parse_message(void *packet, uint8_t *data, uint16_t data_len) +{ + /* Initialize packet */ + memset(packet, 0, sizeof(coap_packet_t)); + + /* pointer to packet bytes */ + ((coap_packet_t *)packet)->buffer = data; + + /* parse header fields */ + ((coap_packet_t *)packet)->version = (COAP_HEADER_VERSION_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_VERSION_POSITION; + ((coap_packet_t *)packet)->type = (COAP_HEADER_TYPE_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_TYPE_POSITION; + ((coap_packet_t *)packet)->option_count = (COAP_HEADER_OPTION_COUNT_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_OPTION_COUNT_POSITION; + ((coap_packet_t *)packet)->code = ((coap_packet_t *)packet)->buffer[1]; + ((coap_packet_t *)packet)->tid = ((coap_packet_t *)packet)->buffer[2]<<8 | ((coap_packet_t *)packet)->buffer[3]; + + if (((coap_packet_t *)packet)->version != 1) + { + coap_error_message = "CoAP version must be 1"; + return BAD_REQUEST_4_00; + } + + /* parse options */ + ((coap_packet_t *)packet)->options = 0x0000; + uint8_t *current_option = data + COAP_HEADER_LEN; + + if (((coap_packet_t *)packet)->option_count) + { + uint8_t option_index = 0; + + uint8_t current_number = 0; + size_t option_len = 0; + + PRINTF("-Parsing %u options-\n", ((coap_packet_t *)packet)->option_count); + for (option_index=0; option_index < ((coap_packet_t *)packet)->option_count; ++option_index) { + + current_number += current_option[0]>>4; + + PRINTF("OPTION %u (type %u, delta %u, len %u): ", option_index, current_number, current_option[0]>>4, (0x0F & current_option[0]) < 15 ? (0x0F & current_option[0]) : current_option[1] + 15); + + if ((0x0F & current_option[0]) < 15) { + option_len = 0x0F & current_option[0]; + current_option += 1; + } else { + option_len = current_option[1] + 15; + current_option += 2; + } + + SET_OPTION((coap_packet_t *)packet, current_number); + + switch (current_number) { + case COAP_OPTION_CONTENT_TYPE: + ((coap_packet_t *)packet)->content_type = parse_int_option(current_option, option_len); + PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type); + break; + case COAP_OPTION_MAX_AGE: + ((coap_packet_t *)packet)->max_age = parse_int_option(current_option, option_len); + PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age); + break; + case COAP_OPTION_PROXY_URI: + /*FIXME check for own end-point */ + ((coap_packet_t *)packet)->proxy_uri = (char *) current_option; + ((coap_packet_t *)packet)->proxy_uri_len = option_len; + /*TODO length > 270 not implemented (actually not required) */ + PRINTF("Proxy-Uri NOT IMPLEMENTED [%.*s]\n", ((coap_packet_t *)packet)->proxy_uri_len, ((coap_packet_t *)packet)->proxy_uri); + coap_error_message = "This is a constrained server (Contiki)"; + return PROXYING_NOT_SUPPORTED_5_05; + break; + case COAP_OPTION_ETAG: + ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, option_len); + memcpy(((coap_packet_t *)packet)->etag, current_option, ((coap_packet_t *)packet)->etag_len); + PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->etag_len, + ((coap_packet_t *)packet)->etag[0], + ((coap_packet_t *)packet)->etag[1], + ((coap_packet_t *)packet)->etag[2], + ((coap_packet_t *)packet)->etag[3], + ((coap_packet_t *)packet)->etag[4], + ((coap_packet_t *)packet)->etag[5], + ((coap_packet_t *)packet)->etag[6], + ((coap_packet_t *)packet)->etag[7] + ); /*FIXME always prints 8 bytes */ + break; + case COAP_OPTION_URI_HOST: + ((coap_packet_t *)packet)->uri_host = (char *) current_option; + ((coap_packet_t *)packet)->uri_host_len = option_len; + PRINTF("Uri-Host [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host); + break; + case COAP_OPTION_LOCATION_PATH: + coap_merge_multi_option(&(((coap_packet_t *)packet)->location_path), &(((coap_packet_t *)packet)->location_path_len), current_option, option_len, '/'); + PRINTF("Location-Path [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path); + break; + case COAP_OPTION_URI_PORT: + ((coap_packet_t *)packet)->uri_port = parse_int_option(current_option, option_len); + PRINTF("Uri-Port [%u]\n", ((coap_packet_t *)packet)->uri_port); + break; + case COAP_OPTION_LOCATION_QUERY: + coap_merge_multi_option(&(((coap_packet_t *)packet)->location_query), &(((coap_packet_t *)packet)->location_query_len), current_option, option_len, '&'); + PRINTF("Location-Query [%.*s]\n", ((coap_packet_t *)packet)->location_query_len, ((coap_packet_t *)packet)->location_query); + break; + case COAP_OPTION_URI_PATH: + coap_merge_multi_option(&(((coap_packet_t *)packet)->uri_path), &(((coap_packet_t *)packet)->uri_path_len), current_option, option_len, '/'); + PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path); + break; + case COAP_OPTION_OBSERVE: + ((coap_packet_t *)packet)->observe = parse_int_option(current_option, option_len); + PRINTF("Observe [%u]\n", ((coap_packet_t *)packet)->observe); + break; + case COAP_OPTION_TOKEN: + ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, option_len); + memcpy(((coap_packet_t *)packet)->token, current_option, ((coap_packet_t *)packet)->token_len); + PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->token_len, + ((coap_packet_t *)packet)->token[0], + ((coap_packet_t *)packet)->token[1], + ((coap_packet_t *)packet)->token[2], + ((coap_packet_t *)packet)->token[3], + ((coap_packet_t *)packet)->token[4], + ((coap_packet_t *)packet)->token[5], + ((coap_packet_t *)packet)->token[6], + ((coap_packet_t *)packet)->token[7] + ); /*FIXME always prints 8 bytes */ + break; + case COAP_OPTION_FENCE_POST: + PRINTF("Fence-Post\n"); + break; + case COAP_OPTION_URI_QUERY: + coap_merge_multi_option(&(((coap_packet_t *)packet)->uri_query), &(((coap_packet_t *)packet)->uri_query_len), current_option, option_len, '&'); + PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query); + break; + case COAP_OPTION_BLOCK2: + ((coap_packet_t *)packet)->block2_num = parse_int_option(current_option, option_len); + ((coap_packet_t *)packet)->block2_more = (((coap_packet_t *)packet)->block2_num & 0x08)>>3; + ((coap_packet_t *)packet)->block2_size = 16 << (((coap_packet_t *)packet)->block2_num & 0x07); + ((coap_packet_t *)packet)->block2_offset = (((coap_packet_t *)packet)->block2_num & ~0x0F)<<(((coap_packet_t *)packet)->block2_num & 0x07); + ((coap_packet_t *)packet)->block2_num >>= 4; + PRINTF("Block2 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block2_num, ((coap_packet_t *)packet)->block2_more ? "+" : "", ((coap_packet_t *)packet)->block2_size); + break; + case COAP_OPTION_BLOCK1: + PRINTF("Block1 NOT IMPLEMENTED\n"); + /*TODO implement */ + coap_error_message = "Blockwise POST/PUT not supported"; + return NOT_IMPLEMENTED_5_01; + break; + default: + PRINTF("unknown (%u)\n", current_number); + /* Check if critical (odd) */ + if (current_number & 1) + { + coap_error_message = "Unsupported critical option"; + return BAD_OPTION_4_02; + } + } + + current_option += option_len; + } /* for */ + PRINTF("-Done parsing-------\n"); + } /* if (oc) */ + + ((coap_packet_t *)packet)->payload = current_option; + ((coap_packet_t *)packet)->payload_len = data_len - (((coap_packet_t *)packet)->payload - data); + + return NO_ERROR; +} +/*-----------------------------------------------------------------------------------*/ +/*- REST FRAMEWORK FUNCTIONS --------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +int +coap_get_query_variable(void *packet, const char *name, const char **output) +{ + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) { + return coap_get_variable(((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len, name, output); + } + return 0; +} + +int +coap_get_post_variable(void *packet, const char *name, const char **output) +{ + if (((coap_packet_t *)packet)->payload_len) { + return coap_get_variable((const char *)((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len, name, output); + } + return 0; +} +/*-----------------------------------------------------------------------------------*/ +/*- HEADER OPTION GETTERS AND SETTERS -----------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +unsigned int +coap_get_header_content_type(void *packet) +{ + return ((coap_packet_t *)packet)->content_type; +} + +int +coap_set_header_content_type(void *packet, unsigned int content_type) +{ + ((coap_packet_t *)packet)->content_type = (coap_content_type_t) content_type; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_max_age(void *packet, uint32_t *age) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) { + *age = COAP_DEFAULT_MAX_AGE; + } else { + *age = ((coap_packet_t *)packet)->max_age; + } + return 1; +} + +int +coap_set_header_max_age(void *packet, uint32_t age) +{ + ((coap_packet_t *)packet)->max_age = age; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_etag(void *packet, const uint8_t **etag) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) return 0; + + *etag = ((coap_packet_t *)packet)->etag; + return ((coap_packet_t *)packet)->etag_len; +} + +int +coap_set_header_etag(void *packet, uint8_t *etag, size_t etag_len) +{ + ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, etag_len); + memcpy(((coap_packet_t *)packet)->etag, etag, ((coap_packet_t *)packet)->etag_len); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG); + return ((coap_packet_t *)packet)->etag_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_token(void *packet, const uint8_t **token) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) return 0; + + *token = ((coap_packet_t *)packet)->token; + return ((coap_packet_t *)packet)->token_len; +} + +int +coap_set_header_token(void *packet, uint8_t *token, size_t token_len) +{ + ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, token_len); + memcpy(((coap_packet_t *)packet)->token, token, ((coap_packet_t *)packet)->token_len); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN); + return ((coap_packet_t *)packet)->token_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_proxy_uri(void *packet, const char **uri) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI)) return 0; + + *uri = ((coap_packet_t *)packet)->proxy_uri; + return ((coap_packet_t *)packet)->proxy_uri_len; +} + +int +coap_set_header_proxy_uri(void *packet, char *uri) +{ + ((coap_packet_t *)packet)->proxy_uri = uri; + ((coap_packet_t *)packet)->proxy_uri_len = strlen(uri); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI); + return ((coap_packet_t *)packet)->proxy_uri_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_host(void *packet, const char **host) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) return 0; + + *host = ((coap_packet_t *)packet)->uri_host; + return ((coap_packet_t *)packet)->uri_host_len; +} + +int +coap_set_header_uri_host(void *packet, char *host) +{ + ((coap_packet_t *)packet)->uri_host = host; + ((coap_packet_t *)packet)->uri_host_len = strlen(host); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST); + return ((coap_packet_t *)packet)->uri_host_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_path(void *packet, const char **path) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) return 0; + + *path = ((coap_packet_t *)packet)->uri_path; + return ((coap_packet_t *)packet)->uri_path_len; +} + +int +coap_set_header_uri_path(void *packet, char *path) +{ + while (path[0]=='/') ++path; + + ((coap_packet_t *)packet)->uri_path = path; + ((coap_packet_t *)packet)->uri_path_len = strlen(path); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH); + return ((coap_packet_t *)packet)->uri_path_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_query(void *packet, const char **query) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) return 0; + + *query = ((coap_packet_t *)packet)->uri_query; + return ((coap_packet_t *)packet)->uri_query_len; +} + +int +coap_set_header_uri_query(void *packet, char *query) +{ + while (query[0]=='?') ++query; + + ((coap_packet_t *)packet)->uri_query = query; + ((coap_packet_t *)packet)->uri_query_len = strlen(query); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY); + return ((coap_packet_t *)packet)->uri_query_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_location_path(void *packet, const char **path) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) return 0; + + *path = ((coap_packet_t *)packet)->location_path; + return ((coap_packet_t *)packet)->location_path_len; +} + +int +coap_set_header_location_path(void *packet, char *path) +{ + char *query; + + while (path[0]=='/') ++path; + + if ((query = strchr(path, '?'))) + { + coap_set_header_location_query(packet, query+1); + ((coap_packet_t *)packet)->location_path_len = query - path; + } + else + { + ((coap_packet_t *)packet)->location_path_len = strlen(path); + } + + ((coap_packet_t *)packet)->location_path = path; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH); + return ((coap_packet_t *)packet)->location_path_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_location_query(void *packet, const char **query) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY)) return 0; + + *query = ((coap_packet_t *)packet)->location_query; + return ((coap_packet_t *)packet)->location_query_len; +} + +int +coap_set_header_location_query(void *packet, char *query) +{ + while (query[0]=='?') ++query; + + ((coap_packet_t *)packet)->location_query = query; + ((coap_packet_t *)packet)->location_query_len = strlen(query); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY); + return ((coap_packet_t *)packet)->location_query_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_observe(void *packet, uint32_t *observe) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) return 0; + + *observe = ((coap_packet_t *)packet)->observe; + return 1; +} + +int +coap_set_header_observe(void *packet, uint32_t observe) +{ + ((coap_packet_t *)packet)->observe = observe; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_block2(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2)) return 0; + + /* pointers may be NULL to get only specific block parameters */ + if (num!=NULL) *num = ((coap_packet_t *)packet)->block2_num; + if (more!=NULL) *more = ((coap_packet_t *)packet)->block2_more; + if (size!=NULL) *size = ((coap_packet_t *)packet)->block2_size; + if (offset!=NULL) *offset = ((coap_packet_t *)packet)->block2_offset; + + return 1; +} + +int +coap_set_header_block2(void *packet, uint32_t num, uint8_t more, uint16_t size) +{ + if (size<16) return 0; + if (size>2048) return 0; + if (num>0x0FFFFF) return 0; + + ((coap_packet_t *)packet)->block2_num = num; + ((coap_packet_t *)packet)->block2_more = more; + ((coap_packet_t *)packet)->block2_size = size; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_block1(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1)) return 0; + + /* pointers may be NULL to get only specific block parameters */ + if (num!=NULL) *num = ((coap_packet_t *)packet)->block1_num; + if (more!=NULL) *more = ((coap_packet_t *)packet)->block1_more; + if (size!=NULL) *size = ((coap_packet_t *)packet)->block1_size; + if (offset!=NULL) *offset = ((coap_packet_t *)packet)->block1_offset; + + return 1; +} + +int +coap_set_header_block1(void *packet, uint32_t num, uint8_t more, uint16_t size) +{ + if (size<16) return 0; + if (size>2048) return 0; + if (num>0x0FFFFF) return 0; + + ((coap_packet_t *)packet)->block1_num = num; + ((coap_packet_t *)packet)->block1_more = more; + ((coap_packet_t *)packet)->block1_size = size; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +/*- PAYLOAD -------------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +int +coap_get_payload(void *packet, const uint8_t **payload) +{ + if (((coap_packet_t *)packet)->payload) { + *payload = ((coap_packet_t *)packet)->payload; + return ((coap_packet_t *)packet)->payload_len; + } else { + *payload = NULL; + return 0; + } +} + +int +coap_set_payload(void *packet, uint8_t *payload, size_t length) +{ + PRINTF("setting payload (%u/%u)\n", length, REST_MAX_CHUNK_SIZE); + + ((coap_packet_t *)packet)->payload = payload; + ((coap_packet_t *)packet)->payload_len = MIN(REST_MAX_CHUNK_SIZE, length); + + return ((coap_packet_t *)packet)->payload_len; +} +/*-----------------------------------------------------------------------------------*/ diff --git a/apps/er-coap-06/er-coap-06.h b/apps/er-coap-06/er-coap-06.h new file mode 100644 index 000000000..a5ad954e6 --- /dev/null +++ b/apps/er-coap-06/er-coap-06.h @@ -0,0 +1,300 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * An implementation of the Constrained Application Protocol (draft 06) + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_06_H_ +#define COAP_06_H_ + +#include /* for size_t */ +#include "contiki-net.h" +#include "erbium.h" + +#define COAP_DEFAULT_PORT 5683 + +#ifndef COAP_SERVER_PORT +#define COAP_SERVER_PORT COAP_DEFAULT_PORT +#endif + +#define COAP_DEFAULT_MAX_AGE 60 +#define COAP_RESPONSE_TIMEOUT 2 +#define COAP_RESPONSE_RANDOM_FACTOR 1.5 +#define COAP_MAX_RETRANSMIT 4 + +#define COAP_HEADER_LEN 4 /* | oc:0xF0 type:0x0C version:0x03 | code | tid:0x00FF | tid:0xFF00 | */ +#define COAP_ETAG_LEN 8 /* The maximum number of bytes for the ETag */ +#define COAP_TOKEN_LEN 8 /* The maximum number of bytes for the Token */ + +#define COAP_HEADER_VERSION_MASK 0xC0 +#define COAP_HEADER_VERSION_POSITION 6 +#define COAP_HEADER_TYPE_MASK 0x30 +#define COAP_HEADER_TYPE_POSITION 4 +#define COAP_HEADER_OPTION_COUNT_MASK 0x0F +#define COAP_HEADER_OPTION_COUNT_POSITION 0 + +#define COAP_HEADER_OPTION_DELTA_MASK 0xF0 +#define COAP_HEADER_OPTION_SHORT_LENGTH_MASK 0x0F + +/* + * Conservative size limit, as not all options have to be set at the same time. + */ +/* Hdr CoT Age Tag Obs Tok Blo strings */ +#define COAP_MAX_HEADER_SIZE (4 + 3 + 5 + 1+COAP_ETAG_LEN + 3 + 1+COAP_TOKEN_LEN + 4 + 10) /* 50 */ +#define COAP_MAX_PACKET_SIZE (COAP_MAX_HEADER_SIZE + REST_MAX_CHUNK_SIZE) +/* 0/14 48 for IPv6 (28 for IPv4) */ +#if COAP_MAX_PACKET_SIZE > (UIP_BUFSIZE - UIP_LLH_LEN - UIP_IPUDPH_LEN) +#error "UIP_CONF_BUFFER_SIZE too small for REST_MAX_CHUNK_SIZE" +#endif + +/* + * Maximum number of failed request attempts before action + */ +#ifndef COAP_MAX_ATTEMPTS +#define COAP_MAX_ATTEMPTS 4 +#endif /* COAP_MAX_ATTEMPTS */ + +#define UIP_IP_BUF ((struct uip_ip_hdr *)&uip_buf[UIP_LLH_LEN]) +#define UIP_UDP_BUF ((struct uip_udp_hdr *)&uip_buf[uip_l2_l3_hdr_len]) + +#define SET_OPTION(packet, opt) ((packet)->options |= 1L<options & 1L< + */ + +#include +#include +#include +#include "contiki.h" +#include "contiki-net.h" + +#include "er-coap-07-engine.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF(" %02x:%02x:%02x:%02x:%02x:%02x ",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#define PRINTBITS(buf,len) { \ + int i,j=0; \ + for (i=0; i=0; --j) { \ + PRINTF("%c", (((char *)buf)[i] & 1<srcipaddr); + PRINTF(":%u\n Length: %u\n Data: ", uip_ntohs(UIP_UDP_BUF->srcport), data_len ); + PRINTBITS(data, data_len); + PRINTF("\n"); + + coap_error_code = coap_parse_message(message, data, data_len); + + if (coap_error_code==NO_ERROR) + { + + /*TODO duplicates suppression, if required */ + + PRINTF(" Parsed: v %u, t %u, oc %u, c %u, tid %u\n", message->version, message->type, message->option_count, message->code, message->tid); + 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->tid, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport)) ) + { + static uint32_t block_num = 0; + static uint16_t block_size = REST_MAX_CHUNK_SIZE; + static uint32_t block_offset = 0; + static 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->tid); + } + else + { + /* Unreliable NON requests are answered with a NON as well. */ + coap_init_message(response, COAP_TYPE_NON, CONTENT_2_05, coap_get_tid()); + } + + /* resource handlers must take care of different handling (e.g., TOKEN_OPTION_REQUIRED_240) */ + if (IS_OPTION(message, COAP_OPTION_TOKEN)) + { + coap_set_header_token(response, message->token, message->token_len); + SET_OPTION(response, COAP_OPTION_TOKEN); + } + + /* 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; + } + else + { + new_offset = 0; + } + + /* 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)) + { + /* Apply blockwise transfers. */ + 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, (uint8_t*)"Block out of scope", 18); + } + 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) */ + } + } + else + { + coap_error_code = INTERNAL_SERVER_ERROR_5_00; + coap_error_message = "Service callback undefined"; + } /* if (service callback) */ + + /* serialize Response. */ + if ((transaction->packet_len = coap_serialize_message(response, transaction->packet))==0) + { + coap_error_code = PACKET_SERIALIZATION_ERROR; + } + + } else { + coap_error_code = MEMORY_ALLOC_ERR; + coap_error_message = "Transaction buffer allocation failed"; + } /* if (transaction buffer) */ + } + else + { + /* Responses */ + + if (message->type==COAP_TYPE_ACK) + { + PRINTF("Received ACK\n"); + } + else if (message->type==COAP_TYPE_RST) + { + PRINTF("Received RST\n"); + /* Cancel possible subscriptions. */ + if (IS_OPTION(message, COAP_OPTION_TOKEN)) + { + PRINTF(" Token 0x%02X%02X\n", message->token[0], message->token[1]); + coap_remove_observer_by_token(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, message->token, message->token_len); + } + } + + if ( (transaction = coap_get_transaction_by_tid(message->tid)) ) + { + /* 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; + } + } /* if (parsed correctly) */ + + if (coap_error_code==NO_ERROR) { + if (transaction) coap_send_transaction(transaction); + } + else + { + 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; + } + /* Reuse input buffer for error message. */ + coap_init_message(message, COAP_TYPE_ACK, coap_error_code, message->tid); + coap_set_payload(message, (uint8_t *) coap_error_message, strlen(coap_error_message)); + coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, data, coap_serialize_message(message, data)); + } + } /* if (new data) */ + + return coap_error_code; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_receiver_init() +{ + process_start(&coap_receiver, NULL); +} +/*-----------------------------------------------------------------------------------*/ +void +coap_set_service_callback(service_callback_t callback) +{ + service_cbk = callback; +} +/*-----------------------------------------------------------------------------------*/ +rest_resource_flags_t +coap_get_rest_method(void *packet) +{ + return (rest_resource_flags_t)(1 << (((coap_packet_t *)packet)->code - 1)); +} +/*-----------------------------------------------------------------------------------*/ +int +coap_set_rest_status(void *packet, unsigned int code) +{ + if (code <= 0xFF) + { + ((coap_packet_t *)packet)->code = (uint8_t) code; + return 1; + } + else + { + return 0; + } +} +/*-----------------------------------------------------------------------------------*/ +/*- Server part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +/* The discover resource is automatically included for CoAP. */ +RESOURCE(well_known_core, METHOD_GET, ".well-known/core", ""); +void +well_known_core_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + /* Response might be NULL for non-confirmable requests. */ + if (response) + { + size_t strpos = 0; + size_t bufpos = 0; + resource_t* resource = NULL; + + for (resource = (resource_t*)list_head(rest_get_resources()); resource; resource = resource->next) + { + strpos += snprintf((char *) buffer + bufpos, REST_MAX_CHUNK_SIZE - bufpos + 1, + "%s%s%s", + resource->url, + resource->attributes[0] ? ";" : "", + resource->attributes, + resource->next ? "," : "" ); + + PRINTF("discover: %s\n", resource->url); + + if (strpos <= *offset) + { + /* Discard output before current block */ + PRINTF(" if %d <= %ld B\n", strpos, *offset); + PRINTF(" %s\n", buffer); + bufpos = 0; + } + else /* (strpos > *offset) */ + { + /* output partly in block */ + size_t len = MIN(strpos - *offset, preferred_size); + + PRINTF(" el %d/%d @ %ld B\n", len, preferred_size, *offset); + + /* Block might start in the middle of the output; align with buffer start. */ + if (bufpos == 0) + { + memmove(buffer, buffer+strlen((char *)buffer)-strpos+*offset, len); + } + + bufpos = len; + PRINTF(" %s\n", buffer); + + if (bufpos >= preferred_size) + { + break; + } + } + } + + if (bufpos>0) { + coap_set_payload(response, buffer, bufpos ); + coap_set_header_content_type(response, APPLICATION_LINK_FORMAT); + } + else + { + PRINTF("well_known_core_handler(): bufpos<=0\n"); + + coap_set_rest_status(response, BAD_OPTION_4_02); + coap_set_payload(response, (uint8_t*)"Block out of scope", 18); + } + + if (resource==NULL) { + *offset = -1; + } + else + { + *offset += bufpos; + } + } +} +/*-----------------------------------------------------------------------------------*/ +PROCESS_THREAD(coap_receiver, ev, data) +{ + PROCESS_BEGIN(); + PRINTF("Starting CoAP-07 receiver...\n"); + + rest_activate_resource(&resource_well_known_core); + + coap_register_as_transaction_handler(); + coap_init_connection(SERVER_LISTEN_PORT); + PRINTF("Listening on port %u\n", UIP_HTONS(SERVER_LISTEN_PORT)); + + while(1) { + PROCESS_YIELD(); + + if(ev == tcpip_event) { + handle_incoming_data(); + } else if (ev == PROCESS_EVENT_TIMER) { + /* retransmissions are handled here */ + coap_check_transactions(); + } + } /* while (1) */ + + PROCESS_END(); +} +/*-----------------------------------------------------------------------------------*/ +/*- Client part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void blocking_request_callback(void *callback_data, void *response) { + struct request_state_t *state = (struct request_state_t *) callback_data; + state->response = (coap_packet_t*) response; + process_poll(state->process); +} +/*-----------------------------------------------------------------------------------*/ +PT_THREAD(coap_blocking_request(struct request_state_t *state, process_event_t ev, + uip_ipaddr_t *remote_ipaddr, uint16_t remote_port, + coap_packet_t *request, + blocking_response_handler request_callback)) { + PT_BEGIN(&state->pt); + + static uint8_t more; + static uint32_t res_block; + static uint8_t block_error; + + state->block_num = 0; + state->response = NULL; + state->process = PROCESS_CURRENT(); + + more = 0; + res_block = 0; + block_error = 0; + + do { + request->tid = coap_get_tid(); + if ((state->transaction = coap_new_transaction(request->tid, remote_ipaddr, remote_port))) + { + state->transaction->callback = blocking_request_callback; + state->transaction->callback_data = state; + + if (state->block_num>0) + { + coap_set_header_block2(request, state->block_num, 0, REST_MAX_CHUNK_SIZE); + } + + state->transaction->packet_len = coap_serialize_message(request, state->transaction->packet); + + coap_send_transaction(state->transaction); + PRINTF("Requested #%lu (TID %u)\n", state->block_num, request->tid); + + PT_YIELD_UNTIL(&state->pt, ev == PROCESS_EVENT_POLL); + + if (!state->response) + { + PRINTF("Server not responding\n"); + PT_EXIT(&state->pt); + } + + coap_get_header_block2(state->response, &res_block, &more, NULL, NULL); + + PRINTF("Received #%lu%s (%u bytes)\n", res_block, more ? "+" : "", state->response->payload_len); + + if (res_block==state->block_num) + { + request_callback(state->response); + ++(state->block_num); + } + else + { + PRINTF("WRONG BLOCK %lu/%lu\n", res_block, state->block_num); + ++block_error; + } + } + else + { + PRINTF("Could not allocate transaction buffer"); + PT_EXIT(&state->pt); + } + } while (more && block_errorpt); +} +/*-----------------------------------------------------------------------------------*/ +/*- Engine Interface ----------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +const struct rest_implementation coap_rest_implementation = { + "CoAP-07", + + coap_receiver_init, + coap_set_service_callback, + + coap_get_header_uri_path, + coap_set_header_uri_path, + coap_get_rest_method, + coap_set_rest_status, + + coap_get_header_content_type, + coap_set_header_content_type, + coap_get_header_accept, + coap_get_header_max_age, + coap_set_header_max_age, + coap_set_header_etag, + coap_get_header_if_match, + coap_get_header_if_none_match, + coap_get_header_uri_host, + coap_set_header_location_path, + + coap_get_payload, + coap_set_payload, + + coap_get_header_uri_query, + coap_get_query_variable, + coap_get_post_variable, + + coap_notify_observers, + (restful_post_handler) coap_observe_handler, + + NULL, /* default pre-handler (set separate handler after activation if needed) */ + NULL, /* default post-handler for non-observable resources */ + + { + CONTENT_2_05, + CREATED_2_01, + CHANGED_2_04, + DELETED_2_02, + VALID_2_03, + BAD_REQUEST_4_00, + UNAUTHORIZED_4_01, + BAD_OPTION_4_02, + FORBIDDEN_4_03, + NOT_FOUND_4_04, + METHOD_NOT_ALLOWED_4_05, + REQUEST_ENTITY_TOO_LARGE_4_13, + UNSUPPORTED_MADIA_TYPE_4_15, + INTERNAL_SERVER_ERROR_5_00, + NOT_IMPLEMENTED_5_01, + BAD_GATEWAY_5_02, + SERVICE_UNAVAILABLE_5_03, + GATEWAY_TIMEOUT_5_04, + PROXYING_NOT_SUPPORTED_5_05 + }, + + { + TEXT_PLAIN, + TEXT_XML, + TEXT_CSV, + TEXT_HTML, + IMAGE_GIF, + IMAGE_JPEG, + IMAGE_PNG, + IMAGE_TIFF, + AUDIO_RAW, + VIDEO_RAW, + APPLICATION_LINK_FORMAT, + APPLICATION_XML, + APPLICATION_OCTET_STREAM, + APPLICATION_RDF_XML, + APPLICATION_SOAP_XML, + APPLICATION_ATOM_XML, + APPLICATION_XMPP_XML, + APPLICATION_EXI, + APPLICATION_FASTINFOSET, + APPLICATION_SOAP_FASTINFOSET, + APPLICATION_JSON, + APPLICATION_X_OBIX_BINARY + } +}; diff --git a/apps/er-coap-07/er-coap-07-engine.h b/apps/er-coap-07/er-coap-07-engine.h new file mode 100644 index 000000000..f971c2ec7 --- /dev/null +++ b/apps/er-coap-07/er-coap-07-engine.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP implementation of the REST Engine + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_SERVER_H_ +#define COAP_SERVER_H_ + +#if !defined(REST) +#error "Define REST to \"coap_rest_implementation\"" +#endif + +#include "er-coap-07.h" +#include "er-coap-07-transactions.h" +#include "er-coap-07-observing.h" +#include "er-coap-07-separate.h" + +#include "pt.h" + +/* Declare server process */ +PROCESS_NAME(coap_receiver); + +#define SERVER_LISTEN_PORT UIP_HTONS(COAP_SERVER_PORT) + +typedef coap_packet_t rest_request_t; +typedef coap_packet_t rest_response_t; + +extern const struct rest_implementation coap_rest_implementation; + +void coap_receiver_init(void); + +/*-----------------------------------------------------------------------------------*/ +/*- Client part ---------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +struct request_state_t { + struct pt pt; + struct process *process; + coap_transaction_t *transaction; + coap_packet_t *response; + uint32_t block_num; +}; + +typedef void (*blocking_response_handler) (void* response); + +PT_THREAD(coap_blocking_request(struct request_state_t *state, process_event_t ev, + uip_ipaddr_t *remote_ipaddr, uint16_t remote_port, + coap_packet_t *request, + blocking_response_handler request_callback)); + +#define COAP_BLOCKING_REQUEST(server_addr, server_port, request, chunk_handler) \ +static struct request_state_t request_state; \ +PT_SPAWN(process_pt, &request_state.pt, \ + coap_blocking_request(&request_state, ev, \ + server_addr, server_port, \ + request, chunk_handler) \ + ); +/*-----------------------------------------------------------------------------------*/ + +#endif /* COAP_SERVER_H_ */ diff --git a/apps/er-coap-07/er-coap-07-observing.c b/apps/er-coap-07/er-coap-07-observing.c new file mode 100644 index 000000000..6c6ed7f1c --- /dev/null +++ b/apps/er-coap-07/er-coap-07-observing.c @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for observing resources + * \author + * Matthias Kovatsch + */ + +#include +#include + +#include "er-coap-07-observing.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +MEMB(observers_memb, coap_observer_t, COAP_MAX_OBSERVERS); +LIST(observers_list); + +/*-----------------------------------------------------------------------------------*/ +coap_observer_t * +coap_add_observer(const char *url, uip_ipaddr_t *addr, uint16_t port, const uint8_t *token, size_t token_len) +{ + coap_observer_t *o = memb_alloc(&observers_memb); + + if (o) + { + o->url = url; + uip_ipaddr_copy(&o->addr, addr); + o->port = port; + o->token_len = token_len; + memcpy(o->token, token, token_len); + + stimer_set(&o->refresh_timer, COAP_OBSERVING_REFRESH_INTERVAL); + + PRINTF("Adding observer for /%s [0x%02X%02X]\n", o->url, o->token[0], o->token[1]); + list_add(observers_list, o); + } + + return o; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_remove_observer(coap_observer_t *o) +{ + PRINTF("Removing observer for /%s [0x%02X%02X]\n", o->url, o->token[0], o->token[1]); + + memb_free(&observers_memb, o); + list_remove(observers_list, o); +} + +int +coap_remove_observer_by_client(uip_ipaddr_t *addr, uint16_t port) +{ + int removed = 0; + coap_observer_t* obs = NULL; + + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + PRINTF("Remove check client "); + PRINT6ADDR(addr); + PRINTF(":%u\n", port); + if (uip_ipaddr_cmp(&obs->addr, addr) && obs->port==port) + { + coap_remove_observer(obs); + removed++; + } + } + return removed; +} +int +coap_remove_observer_by_token(uip_ipaddr_t *addr, uint16_t port, uint8_t *token, size_t token_len) +{ + int removed = 0; + coap_observer_t* obs = NULL; + + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + PRINTF("Remove check Token 0x%02X%02X\n", token[0], token[1]); + if (uip_ipaddr_cmp(&obs->addr, addr) && obs->port==port && memcmp(obs->token, token, token_len)==0) + { + coap_remove_observer(obs); + removed++; + } + } + return removed; +} +int +coap_remove_observer_by_url(const char *url) +{ + int removed = 0; + coap_observer_t* obs = NULL; + + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + PRINTF("Remove check URL %p\n", url); + if (obs->url==url || memcmp(obs->url, url, strlen(obs->url))==0) + { + coap_remove_observer(obs); + removed++; + } + } + return removed; +} +/*-----------------------------------------------------------------------------------*/ +void +coap_notify_observers(const char *url, int type, uint32_t observe, uint8_t *payload, size_t payload_len) +{ + coap_observer_t* obs = NULL; + for (obs = (coap_observer_t*)list_head(observers_list); obs; obs = obs->next) + { + if (obs->url==url) /* using RESOURCE url pointer as handle */ + { + coap_transaction_t *transaction = NULL; + + /*TODO implement special transaction for CON, sharing the same buffer to allow for more observers */ + + if ( (transaction = coap_new_transaction(coap_get_tid(), &obs->addr, obs->port)) ) + { + /* Use CON to check whether client is still there/interested after COAP_OBSERVING_REFRESH_INTERVAL. */ + if (stimer_expired(&obs->refresh_timer)) + { + PRINTF("Observing: Refresh client with CON\n"); + type = COAP_TYPE_CON; + stimer_restart(&obs->refresh_timer); + } + + /* prepare response */ + coap_packet_t push[1]; /* This way the packet can be treated as pointer as usual. */ + coap_init_message(push, (coap_message_type_t)type, CONTENT_2_05, transaction->tid ); + coap_set_header_observe(push, observe); + coap_set_header_token(push, obs->token, obs->token_len); + coap_set_payload(push, payload, payload_len); + transaction->packet_len = coap_serialize_message(push, transaction->packet); + + PRINTF("Observing: Notify from /%s for ", url); + PRINT6ADDR(&obs->addr); + PRINTF(":%u\n", obs->port); + PRINTF(" %.*s\n", payload_len, payload); + + coap_send_transaction(transaction); + } + } + } +} +/*-----------------------------------------------------------------------------------*/ +void +coap_observe_handler(resource_t *resource, void *request, void *response) +{ + static char content[26]; + + if (response && ((coap_packet_t *)response)->code<128) /* response without error code */ + { + if (IS_OPTION((coap_packet_t *)request, COAP_OPTION_OBSERVE)) + { + if (!IS_OPTION((coap_packet_t *)request, COAP_OPTION_TOKEN)) + { + /* Set default token. */ + coap_set_header_token(request, (uint8_t *)"", 1); + } + + if (coap_add_observer(resource->url, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, ((coap_packet_t *)request)->token, ((coap_packet_t *)request)->token_len)) + { + coap_set_header_observe(response, 0); + coap_set_payload(response, (uint8_t *)content, snprintf(content, sizeof(content), "Added as observer %u/%u", list_length(observers_list), COAP_MAX_OBSERVERS)); + } + else + { + ((coap_packet_t *)response)->code = SERVICE_UNAVAILABLE_5_03; + coap_set_payload(response, (uint8_t *)"Too many observers", 18); + } /* if (added observer) */ + } + else /* if (observe) */ + { + /* Remove client if it is currently observing. */ + coap_remove_observer_by_client(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport); + } /* if (observe) */ + } +} diff --git a/apps/er-coap-07/er-coap-07-observing.h b/apps/er-coap-07/er-coap-07-observing.h new file mode 100644 index 000000000..078e9b430 --- /dev/null +++ b/apps/er-coap-07/er-coap-07-observing.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for observing resources + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_OBSERVING_H_ +#define COAP_OBSERVING_H_ + +#include "er-coap-07.h" +#include "er-coap-07-transactions.h" + +#ifndef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS 4 +#endif /* COAP_MAX_OBSERVERS */ + +/* Interval in seconds in which NON notifies are changed to CON notifies to check client. */ +#define COAP_OBSERVING_REFRESH_INTERVAL 60 + +#if COAP_MAX_OPEN_TRANSACTIONS + */ + +#include +#include + +#include "er-coap-07-separate.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +/*-----------------------------------------------------------------------------------*/ +void coap_separate_handler(resource_t *resource, void *request, void *response) +{ + PRINTF("Separate response for /%s \n", resource->url); + /* send separate ACK. */ + coap_packet_t ack[1]; + /* ACK with empty code (0) */ + coap_init_message(ack, COAP_TYPE_ACK, 0, ((coap_packet_t *)request)->tid); + /* Should only overwrite Header which is already parsed to request. */ + coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, (uip_appdata + uip_ext_len), coap_serialize_message(ack, (uip_appdata + uip_ext_len))); + + /* Change response to separate response. */ + ((coap_packet_t *)response)->type = COAP_TYPE_CON; + ((coap_packet_t *)response)->tid = coap_get_tid(); +} diff --git a/apps/er-coap-07/er-coap-07-separate.h b/apps/er-coap-07/er-coap-07-separate.h new file mode 100644 index 000000000..ace2388f5 --- /dev/null +++ b/apps/er-coap-07/er-coap-07-separate.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for separate responses + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_SEPARATE_H_ +#define COAP_SEPARATE_H_ + +#include "er-coap-07.h" + +void coap_separate_handler(resource_t *resource, void *request, void *response); + +#endif /* COAP_SEPARATE_H_ */ diff --git a/apps/er-coap-07/er-coap-07-transactions.c b/apps/er-coap-07/er-coap-07-transactions.c new file mode 100644 index 000000000..739fd746a --- /dev/null +++ b/apps/er-coap-07/er-coap-07-transactions.c @@ -0,0 +1,195 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for reliable transport + * \author + * Matthias Kovatsch + */ + +#include "contiki.h" +#include "contiki-net.h" + +#include "er-coap-07-transactions.h" +#include "er-coap-07-observing.h" + +/* + * Modulo mask (+1 and +0.5 for rounding) for a random number to get the tick number for the random + * retransmission time between COAP_RESPONSE_TIMEOUT and COAP_RESPONSE_TIMEOUT*COAP_RESPONSE_RANDOM_FACTOR. + */ +#define COAP_RESPONSE_TIMEOUT_TICKS (CLOCK_SECOND * COAP_RESPONSE_TIMEOUT) +#define COAP_RESPONSE_TIMEOUT_BACKOFF_MASK ((CLOCK_SECOND * COAP_RESPONSE_TIMEOUT * (COAP_RESPONSE_RANDOM_FACTOR - 1)) + 1.5) + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +MEMB(transactions_memb, coap_transaction_t, COAP_MAX_OPEN_TRANSACTIONS); +LIST(transactions_list); + + +static struct process *transaction_handler_process = NULL; + +void +coap_register_as_transaction_handler() +{ + transaction_handler_process = PROCESS_CURRENT(); +} + +coap_transaction_t * +coap_new_transaction(uint16_t tid, uip_ipaddr_t *addr, uint16_t port) +{ + coap_transaction_t *t = memb_alloc(&transactions_memb); + + if (t) + { + t->tid = tid; + t->retrans_counter = 0; + + /* save client address */ + uip_ipaddr_copy(&t->addr, addr); + t->port = port; + } + + return t; +} + +void +coap_send_transaction(coap_transaction_t *t) +{ + PRINTF("Sending transaction %u\n", t->tid); + + coap_send_message(&t->addr, t->port, t->packet, t->packet_len); + + if (COAP_TYPE_CON==((COAP_HEADER_TYPE_MASK & t->packet[0])>>COAP_HEADER_TYPE_POSITION)) + { + if (t->retrans_countertid); + + if (t->retrans_counter==0) + { + t->retrans_timer.timer.interval = COAP_RESPONSE_TIMEOUT_TICKS + (random_rand() % (clock_time_t) COAP_RESPONSE_TIMEOUT_BACKOFF_MASK); + PRINTF("Initial interval %f\n", (float)t->retrans_timer.timer.interval/CLOCK_SECOND); + } + else + { + t->retrans_timer.timer.interval <<= 1; /* double */ + PRINTF("Doubled (%u) interval %f\n", t->retrans_counter, (float)t->retrans_timer.timer.interval/CLOCK_SECOND); + } + + /*FIXME hack, maybe there is a better way, but avoid posting everything to the process */ + struct process *process_actual = PROCESS_CURRENT(); + process_current = transaction_handler_process; + etimer_restart(&t->retrans_timer); /* interval updated above */ + process_current = process_actual; + + list_add(transactions_list, t); /* List itself makes sure same element is not added twice. */ + + t = NULL; + } + else + { + /* timeout */ + PRINTF("Timeout\n"); + restful_response_handler callback = t->callback; + void *callback_data = t->callback_data; + + /* handle observers */ + coap_remove_observer_by_client(&t->addr, t->port); + + coap_clear_transaction(t); + + if (callback) { + callback(callback_data, NULL); + } + } + } + else + { + coap_clear_transaction(t); + } +} + +void +coap_clear_transaction(coap_transaction_t *t) +{ + if (t) + { + PRINTF("Freeing transaction %u: %p\n", t->tid, t); + + etimer_stop(&t->retrans_timer); + list_remove(transactions_list, t); + memb_free(&transactions_memb, t); + } +} + +coap_transaction_t * +coap_get_transaction_by_tid(uint16_t tid) +{ + coap_transaction_t *t = NULL; + + for (t = (coap_transaction_t*)list_head(transactions_list); t; t = t->next) + { + if (t->tid==tid) + { + PRINTF("Found transaction for TID %u: %p\n", t->tid, t); + return t; + } + } + return NULL; +} + +void +coap_check_transactions() +{ + coap_transaction_t *t = NULL; + + for (t = (coap_transaction_t*)list_head(transactions_list); t; t = t->next) + { + if (etimer_expired(&t->retrans_timer)) + { + ++(t->retrans_counter); + PRINTF("Retransmitting %u (%u)\n", t->tid, t->retrans_counter); + coap_send_transaction(t); + } + } +} diff --git a/apps/er-coap-07/er-coap-07-transactions.h b/apps/er-coap-07/er-coap-07-transactions.h new file mode 100644 index 000000000..e78a2ef55 --- /dev/null +++ b/apps/er-coap-07/er-coap-07-transactions.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP module for reliable transport + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_TRANSACTIONS_H_ +#define COAP_TRANSACTIONS_H_ + +#include "er-coap-07.h" + +/* + * The number of concurrent messages that can be stored for retransmission in the transaction layer. + */ +#ifndef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 4 +#endif /* COAP_MAX_OPEN_TRANSACTIONS */ + +/* container for transactions with message buffer and retransmission info */ +typedef struct coap_transaction { + struct coap_transaction *next; /* for LIST */ + + uint16_t tid; + struct etimer retrans_timer; + uint8_t retrans_counter; + + uip_ipaddr_t addr; + uint16_t port; + + restful_response_handler callback; + void *callback_data; + + uint16_t packet_len; + uint8_t packet[COAP_MAX_PACKET_SIZE+1]; /* +1 for the terminating '\0' to simply and savely use snprintf(buf, len+1, "", ...) in the resource handler. */ +} coap_transaction_t; + +void coap_register_as_transaction_handler(); + +coap_transaction_t *coap_new_transaction(uint16_t tid, uip_ipaddr_t *addr, uint16_t port); +void coap_send_transaction(coap_transaction_t *t); +void coap_clear_transaction(coap_transaction_t *t); +coap_transaction_t *coap_get_transaction_by_tid(uint16_t tid); + +void coap_check_transactions(); + +#endif /* COAP_TRANSACTIONS_H_ */ diff --git a/apps/er-coap-07/er-coap-07.c b/apps/er-coap-07/er-coap-07.c new file mode 100644 index 000000000..34c41a387 --- /dev/null +++ b/apps/er-coap-07/er-coap-07.c @@ -0,0 +1,1098 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * An implementation of the Constrained Application Protocol (draft 07) + * \author + * Matthias Kovatsch + */ + +#include "contiki.h" +#include "contiki-net.h" +#include +#include + +#include "er-coap-07.h" +#include "er-coap-07-transactions.h" + + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +/*-----------------------------------------------------------------------------------*/ +/*- Variables -----------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +static struct uip_udp_conn *udp_conn = NULL; +static uint16_t current_tid = 0; + +coap_status_t coap_error_code = NO_ERROR; +char *coap_error_message = ""; +/*-----------------------------------------------------------------------------------*/ +/*- LOCAL HELP FUNCTIONS ------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +static +uint16_t +log_2(uint16_t value) +{ + uint16_t result = 0; + do { + value = value >> 1; + result++; + } while (value); + + return result ? result - 1 : result; +} +/*-----------------------------------------------------------------------------------*/ +static +uint32_t +parse_int_option(uint8_t *bytes, uint16_t length) +{ + uint32_t var = 0; + int i = 0; + while (i 15) + { + uint8_t delta = COAP_OPTION_FENCE_POST - (*current_number%COAP_OPTION_FENCE_POST); + set_option_header(delta, 0, &buffer[i++]); + *current_number += delta; + + PRINTF("OPTION FENCE POST delta %u\n", delta); + } + return i; +} +/*-----------------------------------------------------------------------------------*/ +static +size_t +serialize_int_option(int number, int current_number, uint8_t *buffer, uint32_t value) +{ + /* Insert fence-posts for large deltas */ + size_t i = insert_option_fence_posts(number, ¤t_number, buffer); + size_t start_i = i; + + uint8_t *option = &buffer[i]; + + if (0xFF000000 & value) buffer[++i] = (uint8_t) (value>>24); + if (0x00FF0000 & value) buffer[++i] = (uint8_t) (value>>16); + if (0x0000FF00 & value) buffer[++i] = (uint8_t) (value>>8); + if (0x000000FF & value) buffer[++i] = (uint8_t) value; + + i += set_option_header(number - current_number, i-start_i, option); + + PRINTF("OPTION type %u, delta %u, len %u\n", number, number - current_number, i-start_i); + + return i; +} +/*-----------------------------------------------------------------------------------*/ +/* + * Pass the char to split the string at in split_option and receive the number of options in split_option on return. + */ +static +size_t +serialize_array_option(int number, int current_number, uint8_t *buffer, uint8_t *array, size_t length, uint8_t *split_option) +{ + /* Insert fence-posts for large deltas */ + size_t i = insert_option_fence_posts(number, ¤t_number, buffer); + + if (split_option!=NULL) + { + int j; + uint8_t *part_start = array; + uint8_t *part_end = NULL; + size_t temp_length; + + char split_char = *split_option; + *split_option = 0; /* Ensure reflecting the created option count */ + + for (j = 0; j<=length; ++j) + { + if (array[j]==split_char || j==length) + { + part_end = array + j; + temp_length = part_end-part_start; + + i += set_option_header(number - current_number, temp_length, &buffer[i]); + memcpy(&buffer[i], part_start, temp_length); + i += temp_length; + + PRINTF("OPTION type %u, delta %u, len %u, part [%.*s]\n", number, number - current_number, i, temp_length, part_start); + + ++(*split_option); + ++j; /* skip the slash */ + current_number = number; + while( array[j]=='/') ++j; + part_start = array + j; + } + } /* for */ + } + else + { + i += set_option_header(number - current_number, length, &buffer[i]); + memcpy(&buffer[i], array, length); + i += length; + + PRINTF("OPTION type %u, delta %u, len %u\n", number, number - current_number, i); + } + + return i; +} +/*-----------------------------------------------------------------------------------*/ +static +void +coap_merge_multi_option(char **dst, size_t *dst_len, uint8_t *option, size_t option_len, char separator) +{ + /* Merge multiple options. */ + if (*dst_len > 0) + { + (*dst)[*dst_len] = separator; + *dst_len += 1; + + /* memmove handles 2-byte option headers */ + memmove((*dst)+(*dst_len), option, option_len); + + *dst_len += option_len; + } + else + { + *dst = (char *) option; /* thus pointer pointer */ + *dst_len = option_len; + } +} +/*-----------------------------------------------------------------------------------*/ +static +int +coap_get_variable(const char *buffer, size_t length, const char *name, const char **output) +{ + const char *start = NULL; + const char *end = NULL; + const char *value_end = NULL; + size_t name_len = 0; + + /*initialize the output buffer first*/ + *output = 0; + + name_len = strlen(name); + end = buffer + length; + + for (start = buffer; start + name_len < end; ++start){ + if ((start == buffer || start[-1] == '&') && start[name_len] == '=' && + strncmp(name, start, name_len)==0) { + + /* Point start to variable value */ + start += name_len + 1; + + /* Point end to the end of the value */ + value_end = (const char *) memchr(start, '&', end - start); + if (value_end == NULL) { + value_end = end; + } + + *output = start; + + return (value_end - start); + } + } + + return 0; +} +/*-----------------------------------------------------------------------------------*/ +/*- MEASSAGE SENDING ----------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void +coap_init_connection(uint16_t port) +{ + /* new connection with remote host */ + udp_conn = udp_new(NULL, 0, NULL); + udp_bind(udp_conn, port); + PRINTF("Listening on port %u\n", uip_ntohs(udp_conn->lport)); + + /* Initialize transaction ID. */ + current_tid = random_rand(); +} +/*-----------------------------------------------------------------------------------*/ +uint16_t +coap_get_tid() +{ + return ++current_tid; +} +/*-----------------------------------------------------------------------------------*/ +/*- MEASSAGE PROCESSING -------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +void +coap_init_message(void *packet, coap_message_type_t type, uint8_t code, uint16_t tid) +{ + /* Important thing */ + memset(packet, 0, sizeof(coap_packet_t)); + + ((coap_packet_t *)packet)->type = type; + ((coap_packet_t *)packet)->code = code; + ((coap_packet_t *)packet)->tid = tid; +} +/*-----------------------------------------------------------------------------------*/ +size_t +coap_serialize_message(void *packet, uint8_t *buffer) +{ + /* Initialize */ + ((coap_packet_t *)packet)->buffer = buffer; + ((coap_packet_t *)packet)->version = 1; + ((coap_packet_t *)packet)->option_count = 0; + + /* serialize options */ + uint8_t *option = ((coap_packet_t *)packet)->buffer + COAP_HEADER_LEN; + int current_number = 0; + + PRINTF("-Serializing options-\n"); + + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE)) { + PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type); + + option += serialize_int_option(COAP_OPTION_CONTENT_TYPE, current_number, option, ((coap_packet_t *)packet)->content_type); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_CONTENT_TYPE; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) { + PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age); + + option += serialize_int_option(COAP_OPTION_MAX_AGE, current_number, option, ((coap_packet_t *)packet)->max_age); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_MAX_AGE; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI)) { + PRINTF("Proxy-Uri [%.*s]\n", ((coap_packet_t *)packet)->proxy_uri_len, ((coap_packet_t *)packet)->proxy_uri); + + int length = ((coap_packet_t *)packet)->proxy_uri_len; + int j = 0; + while (length>0) + { + option += serialize_array_option(COAP_OPTION_PROXY_URI, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->proxy_uri + j*270, MIN(270, length), NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_PROXY_URI; + + ++j; + length -= 270; + } + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) { + PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->etag_len, + ((coap_packet_t *)packet)->etag[0], + ((coap_packet_t *)packet)->etag[1], + ((coap_packet_t *)packet)->etag[2], + ((coap_packet_t *)packet)->etag[3], + ((coap_packet_t *)packet)->etag[4], + ((coap_packet_t *)packet)->etag[5], + ((coap_packet_t *)packet)->etag[6], + ((coap_packet_t *)packet)->etag[7] + ); /*FIXME always prints 8 bytes */ + + option += serialize_array_option(COAP_OPTION_ETAG, current_number, option, ((coap_packet_t *)packet)->etag, ((coap_packet_t *)packet)->etag_len, NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_ETAG; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) { + PRINTF("Uri-Host [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host); + + option += serialize_array_option(COAP_OPTION_URI_HOST, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_host, ((coap_packet_t *)packet)->uri_host_len, NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_URI_HOST; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) { + PRINTF("Location [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path); + + uint8_t split_options = '/'; + + option += serialize_array_option(COAP_OPTION_LOCATION_PATH, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->location_path, ((coap_packet_t *)packet)->location_path_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options; + current_number = COAP_OPTION_LOCATION_PATH; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PORT)) { + PRINTF("Uri-Port [%u]\n", ((coap_packet_t *)packet)->uri_port); + + option += serialize_int_option(COAP_OPTION_URI_PORT, current_number, option, ((coap_packet_t *)packet)->uri_port); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_URI_PORT; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY)) { + PRINTF("Location-Query [%.*s]\n", ((coap_packet_t *)packet)->location_query_len, ((coap_packet_t *)packet)->location_query); + + uint8_t split_options = '&'; + + option += serialize_array_option(COAP_OPTION_LOCATION_QUERY, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->location_query, ((coap_packet_t *)packet)->location_query_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options; + current_number = COAP_OPTION_LOCATION_QUERY; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) { + PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path); + + uint8_t split_options = '/'; + + option += serialize_array_option(COAP_OPTION_URI_PATH, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_path, ((coap_packet_t *)packet)->uri_path_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options; + current_number = COAP_OPTION_URI_PATH; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) { + PRINTF("Observe [%u]\n", ((coap_packet_t *)packet)->observe); + + option += serialize_int_option(COAP_OPTION_OBSERVE, current_number, option, ((coap_packet_t *)packet)->observe); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_OBSERVE; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) { + PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->token_len, + ((coap_packet_t *)packet)->token[0], + ((coap_packet_t *)packet)->token[1], + ((coap_packet_t *)packet)->token[2], + ((coap_packet_t *)packet)->token[3], + ((coap_packet_t *)packet)->token[4], + ((coap_packet_t *)packet)->token[5], + ((coap_packet_t *)packet)->token[6], + ((coap_packet_t *)packet)->token[7] + ); /*FIXME always prints 8 bytes */ + + option += serialize_array_option(COAP_OPTION_TOKEN, current_number, option, ((coap_packet_t *)packet)->token, ((coap_packet_t *)packet)->token_len, NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_TOKEN; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ACCEPT)) { + int i; + for (i=0; i<((coap_packet_t *)packet)->accept_num; ++i) + { + PRINTF("Accept [%u]\n", ((coap_packet_t *)packet)->accept[i]); + + option += serialize_int_option(COAP_OPTION_ACCEPT, current_number, option, (uint32_t)((coap_packet_t *)packet)->accept[i]); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_ACCEPT; + } + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_MATCH)) { + PRINTF("If-Match [FIXME]\n"); + + option += serialize_array_option(COAP_OPTION_IF_MATCH, current_number, option, ((coap_packet_t *)packet)->if_match, ((coap_packet_t *)packet)->if_match_len, NULL); + ((coap_packet_t *)packet)->option_count += 1; + current_number = COAP_OPTION_IF_MATCH; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) { + PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query); + + uint8_t split_options = '&'; + + option += serialize_array_option(COAP_OPTION_URI_QUERY, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len, &split_options); + ((coap_packet_t *)packet)->option_count += split_options + (COAP_OPTION_URI_QUERY-current_number)/COAP_OPTION_FENCE_POST; + current_number = COAP_OPTION_URI_QUERY; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2)) + { + PRINTF("Block2 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block2_num, ((coap_packet_t *)packet)->block2_more ? "+" : "", ((coap_packet_t *)packet)->block2_size); + + uint32_t block = ((coap_packet_t *)packet)->block2_num << 4; + if (((coap_packet_t *)packet)->block2_more) block |= 0x8; + block |= 0xF & log_2(((coap_packet_t *)packet)->block2_size/16); + + PRINTF("Block2 encoded: 0x%lX\n", block); + + option += serialize_int_option(COAP_OPTION_BLOCK2, current_number, option, block); + + ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_BLOCK2-current_number)/COAP_OPTION_FENCE_POST; + current_number = COAP_OPTION_BLOCK2; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1)) + { + PRINTF("Block1 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block1_num, ((coap_packet_t *)packet)->block1_more ? "+" : "", ((coap_packet_t *)packet)->block1_size); + + uint32_t block = ((coap_packet_t *)packet)->block1_num << 4; + if (((coap_packet_t *)packet)->block1_more) block |= 0x8; + block |= 0xF & log_2(((coap_packet_t *)packet)->block1_size/16); + + PRINTF("Block1 encoded: 0x%lX\n", block); + + option += serialize_int_option(COAP_OPTION_BLOCK1, current_number, option, block); + + ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_BLOCK1-current_number)/COAP_OPTION_FENCE_POST; + current_number = COAP_OPTION_BLOCK1; + } + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_NONE_MATCH)) { + PRINTF("If-None-Match\n"); + + option += serialize_int_option(COAP_OPTION_IF_NONE_MATCH, current_number, option, 0); + + ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_IF_NONE_MATCH-current_number)/COAP_OPTION_FENCE_POST; + current_number = COAP_OPTION_IF_NONE_MATCH; + } + + /* pack payload */ + if ((option - ((coap_packet_t *)packet)->buffer)<=COAP_MAX_HEADER_SIZE) + { + memmove(option, ((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len); + } + else + { + /* An error occured. Caller must check for !=0. */ + ((coap_packet_t *)packet)->buffer = NULL; + coap_error_message = "Serialized header exceeds COAP_MAX_HEADER_SIZE"; + return 0; + } + + /* set header fields */ + ((coap_packet_t *)packet)->buffer[0] = 0x00; + ((coap_packet_t *)packet)->buffer[0] |= COAP_HEADER_VERSION_MASK & (((coap_packet_t *)packet)->version)<buffer[0] |= COAP_HEADER_TYPE_MASK & (((coap_packet_t *)packet)->type)<buffer[0] |= COAP_HEADER_OPTION_COUNT_MASK & (((coap_packet_t *)packet)->option_count)<buffer[1] = ((coap_packet_t *)packet)->code; + ((coap_packet_t *)packet)->buffer[2] = 0xFF & (((coap_packet_t *)packet)->tid)>>8; + ((coap_packet_t *)packet)->buffer[3] = 0xFF & ((coap_packet_t *)packet)->tid; + + PRINTF("-Done %u options, header len %u, payload len %u-\n", ((coap_packet_t *)packet)->option_count, option - buffer, ((coap_packet_t *)packet)->payload_len); + + return (option - buffer) + ((coap_packet_t *)packet)->payload_len; /* packet length */ +} +/*-----------------------------------------------------------------------------------*/ +void +coap_send_message(uip_ipaddr_t *addr, uint16_t port, uint8_t *data, uint16_t length) +{ + /*configure connection to reply to client*/ + uip_ipaddr_copy(&udp_conn->ripaddr, addr); + udp_conn->rport = port; + + uip_udp_packet_send(udp_conn, data, length); + PRINTF("-sent UDP datagram (%u)-\n", length); + + /* Restore server connection to allow data from any node */ + memset(&udp_conn->ripaddr, 0, sizeof(udp_conn->ripaddr)); + udp_conn->rport = 0; +} +/*-----------------------------------------------------------------------------------*/ +coap_status_t +coap_parse_message(void *packet, uint8_t *data, uint16_t data_len) +{ + /* Initialize packet */ + memset(packet, 0, sizeof(coap_packet_t)); + + /* pointer to packet bytes */ + ((coap_packet_t *)packet)->buffer = data; + + /* parse header fields */ + ((coap_packet_t *)packet)->version = (COAP_HEADER_VERSION_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_VERSION_POSITION; + ((coap_packet_t *)packet)->type = (COAP_HEADER_TYPE_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_TYPE_POSITION; + ((coap_packet_t *)packet)->option_count = (COAP_HEADER_OPTION_COUNT_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_OPTION_COUNT_POSITION; + ((coap_packet_t *)packet)->code = ((coap_packet_t *)packet)->buffer[1]; + ((coap_packet_t *)packet)->tid = ((coap_packet_t *)packet)->buffer[2]<<8 | ((coap_packet_t *)packet)->buffer[3]; + + if (((coap_packet_t *)packet)->version != 1) + { + coap_error_message = "CoAP version must be 1"; + return BAD_REQUEST_4_00; + } + + /* parse options */ + ((coap_packet_t *)packet)->options = 0x0000; + uint8_t *current_option = data + COAP_HEADER_LEN; + + if (((coap_packet_t *)packet)->option_count) + { + uint8_t option_index = 0; + + uint8_t current_number = 0; + size_t option_len = 0; + + PRINTF("-Parsing %u options-\n", ((coap_packet_t *)packet)->option_count); + for (option_index=0; option_index < ((coap_packet_t *)packet)->option_count; ++option_index) { + + current_number += current_option[0]>>4; + + PRINTF("OPTION %u (type %u, delta %u, len %u): ", option_index, current_number, current_option[0]>>4, (0x0F & current_option[0]) < 15 ? (0x0F & current_option[0]) : current_option[1] + 15); + + if ((0x0F & current_option[0]) < 15) { + option_len = 0x0F & current_option[0]; + current_option += 1; + } else { + option_len = current_option[1] + 15; + current_option += 2; + } + + SET_OPTION((coap_packet_t *)packet, current_number); + + switch (current_number) { + case COAP_OPTION_CONTENT_TYPE: + ((coap_packet_t *)packet)->content_type = parse_int_option(current_option, option_len); + PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type); + break; + case COAP_OPTION_MAX_AGE: + ((coap_packet_t *)packet)->max_age = parse_int_option(current_option, option_len); + PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age); + break; + case COAP_OPTION_PROXY_URI: + /*FIXME check for own end-point */ + ((coap_packet_t *)packet)->proxy_uri = (char *) current_option; + ((coap_packet_t *)packet)->proxy_uri_len = option_len; + /*TODO length > 270 not implemented (actually not required) */ + PRINTF("Proxy-Uri NOT IMPLEMENTED [%.*s]\n", ((coap_packet_t *)packet)->proxy_uri_len, ((coap_packet_t *)packet)->proxy_uri); + coap_error_message = "This is a constrained server (Contiki)"; + return PROXYING_NOT_SUPPORTED_5_05; + break; + case COAP_OPTION_ETAG: + ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, option_len); + memcpy(((coap_packet_t *)packet)->etag, current_option, ((coap_packet_t *)packet)->etag_len); + PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->etag_len, + ((coap_packet_t *)packet)->etag[0], + ((coap_packet_t *)packet)->etag[1], + ((coap_packet_t *)packet)->etag[2], + ((coap_packet_t *)packet)->etag[3], + ((coap_packet_t *)packet)->etag[4], + ((coap_packet_t *)packet)->etag[5], + ((coap_packet_t *)packet)->etag[6], + ((coap_packet_t *)packet)->etag[7] + ); /*FIXME always prints 8 bytes */ + break; + case COAP_OPTION_URI_HOST: + ((coap_packet_t *)packet)->uri_host = (char *) current_option; + ((coap_packet_t *)packet)->uri_host_len = option_len; + PRINTF("Uri-Host [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host); + break; + case COAP_OPTION_LOCATION_PATH: + coap_merge_multi_option(&(((coap_packet_t *)packet)->location_path), &(((coap_packet_t *)packet)->location_path_len), current_option, option_len, '/'); + PRINTF("Location-Path [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path); + break; + case COAP_OPTION_URI_PORT: + ((coap_packet_t *)packet)->uri_port = parse_int_option(current_option, option_len); + PRINTF("Uri-Port [%u]\n", ((coap_packet_t *)packet)->uri_port); + break; + case COAP_OPTION_LOCATION_QUERY: + coap_merge_multi_option(&(((coap_packet_t *)packet)->location_query), &(((coap_packet_t *)packet)->location_query_len), current_option, option_len, '&'); + PRINTF("Location-Query [%.*s]\n", ((coap_packet_t *)packet)->location_query_len, ((coap_packet_t *)packet)->location_query); + break; + case COAP_OPTION_URI_PATH: + coap_merge_multi_option(&(((coap_packet_t *)packet)->uri_path), &(((coap_packet_t *)packet)->uri_path_len), current_option, option_len, '/'); + PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path); + break; + case COAP_OPTION_OBSERVE: + ((coap_packet_t *)packet)->observe = parse_int_option(current_option, option_len); + PRINTF("Observe [%u]\n", ((coap_packet_t *)packet)->observe); + break; + case COAP_OPTION_TOKEN: + ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, option_len); + memcpy(((coap_packet_t *)packet)->token, current_option, ((coap_packet_t *)packet)->token_len); + PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->token_len, + ((coap_packet_t *)packet)->token[0], + ((coap_packet_t *)packet)->token[1], + ((coap_packet_t *)packet)->token[2], + ((coap_packet_t *)packet)->token[3], + ((coap_packet_t *)packet)->token[4], + ((coap_packet_t *)packet)->token[5], + ((coap_packet_t *)packet)->token[6], + ((coap_packet_t *)packet)->token[7] + ); /*FIXME always prints 8 bytes */ + break; + case COAP_OPTION_ACCEPT: + if (((coap_packet_t *)packet)->accept_num < COAP_MAX_ACCEPT_NUM) + { + ((coap_packet_t *)packet)->accept[((coap_packet_t *)packet)->accept_num] = parse_int_option(current_option, option_len); + ((coap_packet_t *)packet)->accept_num += 1; + PRINTF("Accept [%u]\n", ((coap_packet_t *)packet)->content_type); + } + break; + case COAP_OPTION_IF_MATCH: + /*FIXME support multiple ETags */ + ((coap_packet_t *)packet)->if_match_len = MIN(COAP_ETAG_LEN, option_len); + memcpy(((coap_packet_t *)packet)->if_match, current_option, ((coap_packet_t *)packet)->if_match_len); + PRINTF("If-Match %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->if_match_len, + ((coap_packet_t *)packet)->if_match[0], + ((coap_packet_t *)packet)->if_match[1], + ((coap_packet_t *)packet)->if_match[2], + ((coap_packet_t *)packet)->if_match[3], + ((coap_packet_t *)packet)->if_match[4], + ((coap_packet_t *)packet)->if_match[5], + ((coap_packet_t *)packet)->if_match[6], + ((coap_packet_t *)packet)->if_match[7] + ); /*FIXME always prints 8 bytes */ + break; + case COAP_OPTION_FENCE_POST: + PRINTF("Fence-Post\n"); + break; + case COAP_OPTION_URI_QUERY: + coap_merge_multi_option(&(((coap_packet_t *)packet)->uri_query), &(((coap_packet_t *)packet)->uri_query_len), current_option, option_len, '&'); + PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query); + break; + case COAP_OPTION_BLOCK2: + ((coap_packet_t *)packet)->block2_num = parse_int_option(current_option, option_len); + ((coap_packet_t *)packet)->block2_more = (((coap_packet_t *)packet)->block2_num & 0x08)>>3; + ((coap_packet_t *)packet)->block2_size = 16 << (((coap_packet_t *)packet)->block2_num & 0x07); + ((coap_packet_t *)packet)->block2_offset = (((coap_packet_t *)packet)->block2_num & ~0x0F)<<(((coap_packet_t *)packet)->block2_num & 0x07); + ((coap_packet_t *)packet)->block2_num >>= 4; + PRINTF("Block2 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block2_num, ((coap_packet_t *)packet)->block2_more ? "+" : "", ((coap_packet_t *)packet)->block2_size); + break; + case COAP_OPTION_BLOCK1: + PRINTF("Block1 NOT IMPLEMENTED\n"); + /*TODO implement */ + coap_error_message = "Blockwise POST/PUT not supported"; + return NOT_IMPLEMENTED_5_01; + break; + case COAP_OPTION_IF_NONE_MATCH: + ((coap_packet_t *)packet)->if_none_match = 1; + PRINTF("If-None-Match\n"); + break; + default: + PRINTF("unknown (%u)\n", current_number); + /* Check if critical (odd) */ + if (current_number & 1) + { + coap_error_message = "Unsupported critical option"; + return BAD_OPTION_4_02; + } + } + + current_option += option_len; + } /* for */ + PRINTF("-Done parsing-------\n"); + } /* if (oc) */ + + ((coap_packet_t *)packet)->payload = current_option; + ((coap_packet_t *)packet)->payload_len = data_len - (((coap_packet_t *)packet)->payload - data); + + return NO_ERROR; +} +/*-----------------------------------------------------------------------------------*/ +/*- REST FRAMEWORK FUNCTIONS --------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +int +coap_get_query_variable(void *packet, const char *name, const char **output) +{ + if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) { + return coap_get_variable(((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len, name, output); + } + return 0; +} + +int +coap_get_post_variable(void *packet, const char *name, const char **output) +{ + if (((coap_packet_t *)packet)->payload_len) { + return coap_get_variable((const char *)((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len, name, output); + } + return 0; +} +/*-----------------------------------------------------------------------------------*/ +/*- HEADER OPTION GETTERS AND SETTERS -----------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +unsigned int +coap_get_header_content_type(void *packet) +{ + return ((coap_packet_t *)packet)->content_type; +} + +int +coap_set_header_content_type(void *packet, unsigned int content_type) +{ + ((coap_packet_t *)packet)->content_type = (coap_content_type_t) content_type; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_accept(void *packet, uint16_t **accept) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ACCEPT)) return 0; + + *accept = ((coap_packet_t *)packet)->accept; + return ((coap_packet_t *)packet)->accept_num; +} + +int +coap_set_header_accept(void *packet, uint16_t accept) +{ + if (((coap_packet_t *)packet)->accept_num < COAP_MAX_ACCEPT_NUM) + { + ((coap_packet_t *)packet)->accept[((coap_packet_t *)packet)->accept_num] = accept; + ((coap_packet_t *)packet)->accept_num += 1; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_ACCEPT); + } + return ((coap_packet_t *)packet)->accept_num; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_max_age(void *packet, uint32_t *age) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) { + *age = COAP_DEFAULT_MAX_AGE; + } else { + *age = ((coap_packet_t *)packet)->max_age; + } + return 1; +} + +int +coap_set_header_max_age(void *packet, uint32_t age) +{ + ((coap_packet_t *)packet)->max_age = age; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_etag(void *packet, const uint8_t **etag) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) return 0; + + *etag = ((coap_packet_t *)packet)->etag; + return ((coap_packet_t *)packet)->etag_len; +} + +int +coap_set_header_etag(void *packet, uint8_t *etag, size_t etag_len) +{ + ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, etag_len); + memcpy(((coap_packet_t *)packet)->etag, etag, ((coap_packet_t *)packet)->etag_len); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG); + return ((coap_packet_t *)packet)->etag_len; +} +/*-----------------------------------------------------------------------------------*/ +/*FIXME support multiple ETags */ +int +coap_get_header_if_match(void *packet, const uint8_t **etag) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_MATCH)) return 0; + + *etag = ((coap_packet_t *)packet)->if_match; + return ((coap_packet_t *)packet)->if_match_len; +} + +int +coap_set_header_if_match(void *packet, uint8_t *etag, size_t etag_len) +{ + ((coap_packet_t *)packet)->if_match_len = MIN(COAP_ETAG_LEN, etag_len); + memcpy(((coap_packet_t *)packet)->if_match, etag, ((coap_packet_t *)packet)->if_match_len); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_MATCH); + return ((coap_packet_t *)packet)->if_match_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_if_none_match(void *packet) +{ + return IS_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_NONE_MATCH) ? 1 : 0; +} + +int +coap_set_header_if_none_match(void *packet) +{ + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_NONE_MATCH); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_token(void *packet, const uint8_t **token) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) return 0; + + *token = ((coap_packet_t *)packet)->token; + return ((coap_packet_t *)packet)->token_len; +} + +int +coap_set_header_token(void *packet, uint8_t *token, size_t token_len) +{ + ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, token_len); + memcpy(((coap_packet_t *)packet)->token, token, ((coap_packet_t *)packet)->token_len); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN); + return ((coap_packet_t *)packet)->token_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_proxy_uri(void *packet, const char **uri) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI)) return 0; + + *uri = ((coap_packet_t *)packet)->proxy_uri; + return ((coap_packet_t *)packet)->proxy_uri_len; +} + +int +coap_set_header_proxy_uri(void *packet, char *uri) +{ + ((coap_packet_t *)packet)->proxy_uri = uri; + ((coap_packet_t *)packet)->proxy_uri_len = strlen(uri); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI); + return ((coap_packet_t *)packet)->proxy_uri_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_host(void *packet, const char **host) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) return 0; + + *host = ((coap_packet_t *)packet)->uri_host; + return ((coap_packet_t *)packet)->uri_host_len; +} + +int +coap_set_header_uri_host(void *packet, char *host) +{ + ((coap_packet_t *)packet)->uri_host = host; + ((coap_packet_t *)packet)->uri_host_len = strlen(host); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST); + return ((coap_packet_t *)packet)->uri_host_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_path(void *packet, const char **path) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) return 0; + + *path = ((coap_packet_t *)packet)->uri_path; + return ((coap_packet_t *)packet)->uri_path_len; +} + +int +coap_set_header_uri_path(void *packet, char *path) +{ + while (path[0]=='/') ++path; + + ((coap_packet_t *)packet)->uri_path = path; + ((coap_packet_t *)packet)->uri_path_len = strlen(path); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH); + return ((coap_packet_t *)packet)->uri_path_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_uri_query(void *packet, const char **query) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) return 0; + + *query = ((coap_packet_t *)packet)->uri_query; + return ((coap_packet_t *)packet)->uri_query_len; +} + +int +coap_set_header_uri_query(void *packet, char *query) +{ + while (query[0]=='?') ++query; + + ((coap_packet_t *)packet)->uri_query = query; + ((coap_packet_t *)packet)->uri_query_len = strlen(query); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY); + return ((coap_packet_t *)packet)->uri_query_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_location_path(void *packet, const char **path) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) return 0; + + *path = ((coap_packet_t *)packet)->location_path; + return ((coap_packet_t *)packet)->location_path_len; +} + +int +coap_set_header_location_path(void *packet, char *path) +{ + char *query; + + while (path[0]=='/') ++path; + + if ((query = strchr(path, '?'))) + { + coap_set_header_location_query(packet, query+1); + ((coap_packet_t *)packet)->location_path_len = query - path; + } + else + { + ((coap_packet_t *)packet)->location_path_len = strlen(path); + } + + ((coap_packet_t *)packet)->location_path = path; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH); + return ((coap_packet_t *)packet)->location_path_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_location_query(void *packet, const char **query) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY)) return 0; + + *query = ((coap_packet_t *)packet)->location_query; + return ((coap_packet_t *)packet)->location_query_len; +} + +int +coap_set_header_location_query(void *packet, char *query) +{ + while (query[0]=='?') ++query; + + ((coap_packet_t *)packet)->location_query = query; + ((coap_packet_t *)packet)->location_query_len = strlen(query); + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY); + return ((coap_packet_t *)packet)->location_query_len; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_observe(void *packet, uint32_t *observe) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) return 0; + + *observe = ((coap_packet_t *)packet)->observe; + return 1; +} + +int +coap_set_header_observe(void *packet, uint32_t observe) +{ + ((coap_packet_t *)packet)->observe = observe; + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_block2(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2)) return 0; + + /* pointers may be NULL to get only specific block parameters */ + if (num!=NULL) *num = ((coap_packet_t *)packet)->block2_num; + if (more!=NULL) *more = ((coap_packet_t *)packet)->block2_more; + if (size!=NULL) *size = ((coap_packet_t *)packet)->block2_size; + if (offset!=NULL) *offset = ((coap_packet_t *)packet)->block2_offset; + + return 1; +} + +int +coap_set_header_block2(void *packet, uint32_t num, uint8_t more, uint16_t size) +{ + if (size<16) return 0; + if (size>2048) return 0; + if (num>0x0FFFFF) return 0; + + ((coap_packet_t *)packet)->block2_num = num; + ((coap_packet_t *)packet)->block2_more = more; + ((coap_packet_t *)packet)->block2_size = size; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +int +coap_get_header_block1(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset) +{ + if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1)) return 0; + + /* pointers may be NULL to get only specific block parameters */ + if (num!=NULL) *num = ((coap_packet_t *)packet)->block1_num; + if (more!=NULL) *more = ((coap_packet_t *)packet)->block1_more; + if (size!=NULL) *size = ((coap_packet_t *)packet)->block1_size; + if (offset!=NULL) *offset = ((coap_packet_t *)packet)->block1_offset; + + return 1; +} + +int +coap_set_header_block1(void *packet, uint32_t num, uint8_t more, uint16_t size) +{ + if (size<16) return 0; + if (size>2048) return 0; + if (num>0x0FFFFF) return 0; + + ((coap_packet_t *)packet)->block1_num = num; + ((coap_packet_t *)packet)->block1_more = more; + ((coap_packet_t *)packet)->block1_size = size; + + SET_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1); + return 1; +} +/*-----------------------------------------------------------------------------------*/ +/*- PAYLOAD -------------------------------------------------------------------------*/ +/*-----------------------------------------------------------------------------------*/ +int +coap_get_payload(void *packet, const uint8_t **payload) +{ + if (((coap_packet_t *)packet)->payload) { + *payload = ((coap_packet_t *)packet)->payload; + return ((coap_packet_t *)packet)->payload_len; + } else { + *payload = NULL; + return 0; + } +} + +int +coap_set_payload(void *packet, uint8_t *payload, size_t length) +{ + PRINTF("setting payload (%u/%u)\n", length, REST_MAX_CHUNK_SIZE); + + ((coap_packet_t *)packet)->payload = payload; + ((coap_packet_t *)packet)->payload_len = MIN(REST_MAX_CHUNK_SIZE, length); + + return ((coap_packet_t *)packet)->payload_len; +} +/*-----------------------------------------------------------------------------------*/ diff --git a/apps/er-coap-07/er-coap-07.h b/apps/er-coap-07/er-coap-07.h new file mode 100644 index 000000000..13c83b1e0 --- /dev/null +++ b/apps/er-coap-07/er-coap-07.h @@ -0,0 +1,319 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * An implementation of the Constrained Application Protocol (draft 07) + * \author + * Matthias Kovatsch + */ + +#ifndef COAP_07_H_ +#define COAP_07_H_ + +#include /* for size_t */ +#include "contiki-net.h" +#include "erbium.h" + +#define COAP_DEFAULT_PORT 5683 + +#ifndef COAP_SERVER_PORT +#define COAP_SERVER_PORT COAP_DEFAULT_PORT +#endif + +#define COAP_DEFAULT_MAX_AGE 60 +#define COAP_RESPONSE_TIMEOUT 2 +#define COAP_RESPONSE_RANDOM_FACTOR 1.5 +#define COAP_MAX_RETRANSMIT 4 + +#define COAP_HEADER_LEN 4 /* | oc:0xF0 type:0x0C version:0x03 | code | tid:0x00FF | tid:0xFF00 | */ +#define COAP_ETAG_LEN 8 /* The maximum number of bytes for the ETag */ +#define COAP_TOKEN_LEN 8 /* The maximum number of bytes for the Token */ +#define COAP_MAX_ACCEPT_NUM 2 /* The maximum number of accept preferences to parse/store */ + +#define COAP_HEADER_VERSION_MASK 0xC0 +#define COAP_HEADER_VERSION_POSITION 6 +#define COAP_HEADER_TYPE_MASK 0x30 +#define COAP_HEADER_TYPE_POSITION 4 +#define COAP_HEADER_OPTION_COUNT_MASK 0x0F +#define COAP_HEADER_OPTION_COUNT_POSITION 0 + +#define COAP_HEADER_OPTION_DELTA_MASK 0xF0 +#define COAP_HEADER_OPTION_SHORT_LENGTH_MASK 0x0F + +/* + * Conservative size limit, as not all options have to be set at the same time. + */ +/* Hdr CoT Age Tag Obs Tok Blo strings */ +#define COAP_MAX_HEADER_SIZE (4 + 3 + 5 + 1+COAP_ETAG_LEN + 3 + 1+COAP_TOKEN_LEN + 4 + 10) /* 50 */ +#define COAP_MAX_PACKET_SIZE (COAP_MAX_HEADER_SIZE + REST_MAX_CHUNK_SIZE) +/* 0/14 48 for IPv6 (28 for IPv4) */ +#if COAP_MAX_PACKET_SIZE > (UIP_BUFSIZE - UIP_LLH_LEN - UIP_IPUDPH_LEN) +#error "UIP_CONF_BUFFER_SIZE too small for REST_MAX_CHUNK_SIZE" +#endif + +/* + * Maximum number of failed request attempts before action + */ +#ifndef COAP_MAX_ATTEMPTS +#define COAP_MAX_ATTEMPTS 4 +#endif /* COAP_MAX_ATTEMPTS */ + +#define UIP_IP_BUF ((struct uip_ip_hdr *)&uip_buf[UIP_LLH_LEN]) +#define UIP_UDP_BUF ((struct uip_udp_hdr *)&uip_buf[uip_l2_l3_hdr_len]) + +#define SET_OPTION(packet, opt) ((packet)->options |= 1L<options & 1L< + */ + +#include "contiki.h" +#include /*for string operations in match_addresses*/ +#include /*for sprintf in rest_set_header_**/ + +#include "erbium.h" + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF(" %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x ", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF(" %02x:%02x:%02x:%02x:%02x:%02x ",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +PROCESS_NAME(rest_manager_process); + +LIST(restful_services); +LIST(restful_periodic_services); + + +#ifdef WITH_HTTP + +char * +rest_to_http_max_age(uint32_t age) +{ + /* Cache-Control: max-age=age for HTTP */ + static char temp_age[19]; + snprintf(temp_age, sizeof(temp_age), "max-age=%lu", age); + return temp_age; +} + +char * +rest_to_http_etag(uint8_t *etag, uint8_t etag_len) +{ + static char temp_etag[17]; + int index = 0; + + for (index = 0; indexurl); + + if (!resource->pre_handler) + { + rest_set_pre_handler(resource, REST.default_pre_handler); + } + if (!resource->post_handler) + { + rest_set_post_handler(resource, REST.default_post_handler); + } + + list_add(restful_services, resource); +} + +void +rest_activate_periodic_resource(periodic_resource_t* periodic_resource) +{ + list_add(restful_periodic_services, periodic_resource); + rest_activate_resource(periodic_resource->resource); + + rest_set_post_handler(periodic_resource->resource, REST.subscription_handler); +} + +void +rest_activate_event_resource(resource_t* resource) +{ + rest_activate_resource(resource); + rest_set_post_handler(resource, REST.subscription_handler); +} + +list_t +rest_get_resources(void) +{ + return restful_services; +} + + +void* +rest_get_user_data(resource_t* resource) +{ + return resource->user_data; +} + +void +rest_set_user_data(resource_t* resource, void* user_data) +{ + resource->user_data = user_data; +} + +void +rest_set_pre_handler(resource_t* resource, restful_pre_handler pre_handler) +{ + resource->pre_handler = pre_handler; +} + +void +rest_set_post_handler(resource_t* resource, restful_post_handler post_handler) +{ + resource->post_handler = post_handler; +} + +void +rest_set_special_flags(resource_t* resource, rest_resource_flags_t flags) +{ + resource->flags |= flags; +} + +int +rest_invoke_restful_service(void* request, void* response, uint8_t *buffer, uint16_t buffer_size, int32_t *offset) +{ + uint8_t found = 0; + uint8_t allowed = 0; + + PRINTF("rest_invoke_restful_service url /%.*s -->\n", url_len, url); + + resource_t* resource = NULL; + const char *url = NULL; + + for (resource = (resource_t*)list_head(restful_services); resource; resource = resource->next) + { + /*if the web service handles that kind of requests and urls matches*/ + if ((REST.get_url(request, &url)==strlen(resource->url) || (REST.get_url(request, &url)>strlen(resource->url) && (resource->flags & HAS_SUB_RESOURCES))) + && strncmp(resource->url, url, strlen(resource->url)) == 0) + { + found = 1; + rest_resource_flags_t method = REST.get_method_type(request); + + PRINTF("method %u, resource->flags %u\n", (uint16_t)method, resource->flags); + + if (resource->flags & method) + { + allowed = 1; + + /*call pre handler if it exists*/ + if (!resource->pre_handler || resource->pre_handler(resource, request, response)) + { + /* call handler function*/ + resource->handler(request, response, buffer, buffer_size, offset); + + /*call post handler if it exists*/ + if (resource->post_handler) + { + resource->post_handler(resource, request, response); + } + } + } else { + REST.set_response_status(response, REST.status.METHOD_NOT_ALLOWED); + } + break; + } + } + + if (!found) { + REST.set_response_status(response, REST.status.NOT_FOUND); + } + + return found & allowed; +} +/*-----------------------------------------------------------------------------------*/ + +PROCESS(rest_manager_process, "Rest Process"); + +PROCESS_THREAD(rest_manager_process, ev, data) +{ + PROCESS_BEGIN(); + + PROCESS_PAUSE(); + + /* Initialize the PERIODIC_RESOURCE timers, which will be handled by this process. */ + periodic_resource_t* periodic_resource = NULL; + for (periodic_resource = (periodic_resource_t*) list_head(restful_periodic_services); periodic_resource; periodic_resource = periodic_resource->next) { + if (periodic_resource->period) { + PRINTF("Periodic: Set timer for %s to %lu\n", periodic_resource->resource->url, periodic_resource->period); + etimer_set(&periodic_resource->periodic_timer, periodic_resource->period); + } + } + + while (1) { + PROCESS_WAIT_EVENT(); + if (ev == PROCESS_EVENT_TIMER) { + for (periodic_resource = (periodic_resource_t*)list_head(restful_periodic_services);periodic_resource;periodic_resource = periodic_resource->next) { + if (periodic_resource->period && etimer_expired(&periodic_resource->periodic_timer)) { + + PRINTF("Periodic: etimer expired for /%s (period: %lu)\n", periodic_resource->resource->url, periodic_resource->period); + + /* Call the periodic_handler function if it exists. */ + if (periodic_resource->periodic_handler) { + (periodic_resource->periodic_handler)(periodic_resource->resource); + } + etimer_reset(&periodic_resource->periodic_timer); + } + } + } + } + + PROCESS_END(); +} + diff --git a/apps/erbium/erbium.h b/apps/erbium/erbium.h new file mode 100644 index 000000000..4504c5836 --- /dev/null +++ b/apps/erbium/erbium.h @@ -0,0 +1,331 @@ +/* + * Copyright (c) 2011, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * An abstraction layer for RESTful Web services + * \author + * Matthias Kovatsch + */ + +#ifndef ERBIUM_H_ +#define ERBIUM_H_ + +/*includes*/ +#include +#include "contiki.h" +#include "contiki-lib.h" + +/* + * The maximum buffer size that is provided for resource responses and must be respected due to the limited IP buffer. + * Larger data must be handled by the resource and will be sent chunk-wise through a TCP stream or CoAP blocks. + */ +#ifndef REST_MAX_CHUNK_SIZE +#define REST_MAX_CHUNK_SIZE 128 +#endif + +#ifndef MIN +#define MIN(a, b) ((a) < (b)? (a) : (b)) +#endif /* MIN */ + +/* REST method types */ +typedef enum { + /* methods to handle */ + METHOD_GET = (1 << 0), + METHOD_POST = (1 << 1), + METHOD_PUT = (1 << 2), + METHOD_DELETE = (1 << 3), + + /* special flags */ + HAS_SUB_RESOURCES = (1<<7) +} rest_resource_flags_t; + +struct resource_s; +struct periodic_resource_s; + +/* Signatures of handler functions. */ +typedef void (*restful_handler) (void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); +typedef int (*restful_pre_handler) (struct resource_s *resource, void* request, void* response); +typedef void (*restful_post_handler) (struct resource_s *resource, void* request, void* response); +typedef int (*restful_periodic_handler) (struct resource_s* resource); +typedef void (*restful_response_handler) (void *data, void* response); + +/* Signature of the rest-engine service function. */ +typedef int (* service_callback_t)(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/** + * The structure of a MAC protocol driver in Contiki. + */ +struct rest_implementation_status +{ + const unsigned int OK; /* CONTENT_2_05, OK_200 */ + const unsigned int CREATED; /* CREATED_2_01, CREATED_201 */ + const unsigned int CHANGED; /* CHANGED_2_04, NO_CONTENT_204 */ + const unsigned int DELETED; /* DELETED_2_02, NO_CONTENT_204 */ + const unsigned int NOT_MODIFIED; /* VALID_2_03, NOT_MODIFIED_304 */ + + const unsigned int BAD_REQUEST; /* BAD_REQUEST_4_00, BAD_REQUEST_400 */ + const unsigned int UNAUTHORIZED; /* UNAUTHORIZED_4_01, UNAUTHORIZED_401 */ + const unsigned int BAD_OPTION; /* BAD_OPTION_4_02, BAD_REQUEST_400 */ + const unsigned int FORBIDDEN; /* FORBIDDEN_4_03, FORBIDDEN_403 */ + const unsigned int NOT_FOUND; /* NOT_FOUND_4_04, NOT_FOUND_404 */ + const unsigned int METHOD_NOT_ALLOWED; /* METHOD_NOT_ALLOWED_4_05, METHOD_NOT_ALLOWED_405 */ + const unsigned int REQUEST_ENTITY_TOO_LARGE; /* REQUEST_ENTITY_TOO_LARGE_4_13, REQUEST_ENTITY_TOO_LARGE_413 */ + const unsigned int UNSUPPORTED_MADIA_TYPE; /* UNSUPPORTED_MADIA_TYPE_4_15, UNSUPPORTED_MADIA_TYPE_415 */ + + const unsigned int INTERNAL_SERVER_ERROR; /* INTERNAL_SERVER_ERROR_5_00, INTERNAL_SERVER_ERROR_500 */ + const unsigned int NOT_IMPLEMENTED; /* NOT_IMPLEMENTED_5_01, NOT_IMPLEMENTED_501 */ + const unsigned int BAD_GATEWAY; /* BAD_GATEWAY_5_02, BAD_GATEWAY_502 */ + const unsigned int SERVICE_UNAVAILABLE; /* SERVICE_UNAVAILABLE_5_03, SERVICE_UNAVAILABLE_503 */ + const unsigned int GATEWAY_TIMEOUT; /* GATEWAY_TIMEOUT_5_04, GATEWAY_TIMEOUT_504 */ + const unsigned int PROXYING_NOT_SUPPORTED; /* PROXYING_NOT_SUPPORTED_5_05, INTERNAL_SERVER_ERROR_500 */ +}; +struct rest_implementation_type +{ + unsigned int TEXT_PLAIN; + unsigned int TEXT_XML; + unsigned int TEXT_CSV; + unsigned int TEXT_HTML; + unsigned int IMAGE_GIF; + unsigned int IMAGE_JPEG; + unsigned int IMAGE_PNG; + unsigned int IMAGE_TIFF; + unsigned int AUDIO_RAW; + unsigned int VIDEO_RAW; + unsigned int APPLICATION_LINK_FORMAT; + unsigned int APPLICATION_XML; + unsigned int APPLICATION_OCTET_STREAM; + unsigned int APPLICATION_RDF_XML; + unsigned int APPLICATION_SOAP_XML; + unsigned int APPLICATION_ATOM_XML; + unsigned int APPLICATION_XMPP_XML; + unsigned int APPLICATION_EXI; + unsigned int APPLICATION_FASTINFOSET; + unsigned int APPLICATION_SOAP_FASTINFOSET; + unsigned int APPLICATION_JSON; + unsigned int APPLICATION_X_OBIX_BINARY; +}; + +struct rest_implementation { + char *name; + + /** Initialize the REST implementation. */ + void (* init)(void); + + /** Register the RESTful service callback at implementation */ + void (* set_service_callback)(service_callback_t callback); + + /** Get request URI path */ + int (* get_url)(void *request, const char **url); + + int (* set_url)(void *request, char *url); + + /** Get the method of a request. */ + rest_resource_flags_t (* get_method_type)(void *request); + + /** Set the status code of a response. */ + int (* set_response_status)(void *response, unsigned int code); + + /** Get the content-type of a request. */ + unsigned int (* get_header_content_type)(void *request); + + /** Set the content-type of a response. */ + int (* set_header_content_type)(void *response, unsigned int content_type); + + int (* get_header_accept)(void *request, uint16_t **accept); + + /** Get the Max-Age option of a request. */ + int (* get_header_max_age)(void *request, uint32_t *age); + + /** Set the Max-Age option of a response. */ + int (* set_header_max_age)(void *response, uint32_t age); + + /** Set the ETag option of a response. */ + int (* set_header_etag)(void *response, uint8_t *etag, size_t length); + + /** Get the If-Match option of a request. */ + int (* get_header_if_match)(void *request, const uint8_t **etag); + + /** Get the If-Match option of a request. */ + int (* get_header_if_none_match)(void *request); + + /** Get the Host option of a request. */ + int (* get_header_host)(void *request, const char **host); + + /** Set the location option of a response. */ + int (* set_header_location)(void *response, char *location); + + /** Get the payload option of a request. */ + int (* get_request_payload)(void *request, const uint8_t **payload); + + /** Set the payload option of a response. */ + int (* set_response_payload)(void *response, uint8_t *payload, size_t length); + + /** Get the query string of a request. */ + int (* get_query)(void *request, const char **value); + + /** Get the value of a request query key-value pair. */ + int (* get_query_variable)(void *request, const char *name, const char **value); + + /** Get the value of a request POST key-value pair. */ + int (* get_post_variable)(void *request, const char *name, const char **value); + + /** Send the payload to all subscribers of the resource at url. */ + void (* notify_subscribers)(const char *url, int implementation_secific_mode, uint32_t counter, uint8_t *payload, size_t payload_len); + + /** The handler for resource subscriptions. */ + restful_post_handler subscription_handler; + + /** A default pre-handler that is assigned with the RESOURCE macro. */ + restful_pre_handler default_pre_handler; + + /** A default post-handler that is assigned with the RESOURCE macro. */ + restful_post_handler default_post_handler; + + /* REST status codes. */ + const struct rest_implementation_status status; + + /* REST content-types. */ + const struct rest_implementation_type type; +}; + +/* + * Instance of REST implementation + */ +extern const struct rest_implementation REST; + +/* + * Data structure representing a resource in REST. + */ +struct resource_s { + struct resource_s *next; /* for LIST, points to next resource defined */ + rest_resource_flags_t flags; /* handled RESTful methods */ + const char* url; /*handled URL*/ + const char* attributes; /* link-format attributes */ + restful_handler handler; /* handler function */ + restful_pre_handler pre_handler; /* to be called before handler, may perform initializations */ + restful_post_handler post_handler; /* to be called after handler, may perform finalizations (cleanup, etc) */ + void* user_data; /* pointer to user specific data */ + unsigned int benchmark; /* to benchmark resource handler, used for separate response */ +}; +typedef struct resource_s resource_t; + +struct periodic_resource_s { + struct periodic_resource_s *next; /* for LIST, points to next resource defined */ + resource_t *resource; + uint32_t period; + struct etimer periodic_timer; + restful_periodic_handler periodic_handler; +}; +typedef struct periodic_resource_s periodic_resource_t; + + +/* + * Macro to define a Resource + * Resources are statically defined for the sake of efficiency and better memory management. + */ +#define RESOURCE(name, flags, url, attributes) \ +void name##_handler(void *, void *, uint8_t *, uint16_t, int32_t *); \ +resource_t resource_##name = {NULL, flags, url, attributes, name##_handler, NULL, NULL, NULL} + +/* + * Macro to define an event resource + * Like periodic resources, event resources have a post_handler that manages a subscriber list. + * Instead of a periodic_handler, an event_callback must be provided. + */ +#define EVENT_RESOURCE(name, flags, url, attributes) \ +void name##_handler(void *, void *, uint8_t *, uint16_t, int32_t *); \ +resource_t resource_##name = {NULL, flags, url, attributes, name##_handler, NULL, NULL, NULL}; \ +int name##_event_handler(resource_t*) + +/* + * Macro to define a periodic resource + * The corresponding [name]_periodic_handler() function will be called every period. + * For instance polling a sensor and publishing a changed value to subscribed clients would be done there. + * The subscriber list will be maintained by the post_handler rest_subscription_handler() (see rest-mapping header file). + */ +#define PERIODIC_RESOURCE(name, flags, url, attributes, period) \ +void name##_handler(void *, void *, uint8_t *, uint16_t, int32_t *); \ +resource_t resource_##name = {NULL, flags, url, attributes, name##_handler, NULL, NULL, NULL}; \ +int name##_periodic_handler(resource_t*); \ +periodic_resource_t periodic_resource_##name = {NULL, &resource_##name, period, {{0}}, name##_periodic_handler} + + +/* + * Initializes REST framework and starts HTTP or COAP process + */ +void rest_init_framework(void); + +/* + * Resources wanted to be accessible should be activated with the following code. + */ +void rest_activate_resource(resource_t* resource); +void rest_activate_periodic_resource(periodic_resource_t* periodic_resource); +void rest_activate_event_resource(resource_t* resource); + + +/* + * To be called by HTTP/COAP server as a callback function when a new service request appears. + * This function dispatches the corresponding RESTful service. + */ +int rest_invoke_restful_service(void* request, void* response, uint8_t *buffer, uint16_t buffer_size, int32_t *offset); + +/* + * Returns the resource list + */ +list_t rest_get_resources(void); + +/* + * Getter and setter methods for user specific data. + */ +void* rest_get_user_data(resource_t* resource); +void rest_set_user_data(resource_t* resource, void* user_data); + +/* + * Sets the pre handler function of the Resource. + * If set, this function will be called just before the original handler function. + * Can be used to setup work before resource handling. + */ +void rest_set_pre_handler(resource_t* resource, restful_pre_handler pre_handler); + +/* + * Sets the post handler function of the Resource. + * If set, this function will be called just after the original handler function. + * Can be used to do cleanup (deallocate memory, etc) after resource handling. + */ +void rest_set_post_handler(resource_t* resource, restful_post_handler post_handler); + +/* + * Sets resource flags for special properties, e.g., handling of sub-resources of URI-path. + */ +void rest_set_special_flags(resource_t* resource, rest_resource_flags_t flags); + +#endif /*ERBIUM_H_*/ diff --git a/examples/er-rest-example/Makefile b/examples/er-rest-example/Makefile new file mode 100644 index 000000000..2d2227c8f --- /dev/null +++ b/examples/er-rest-example/Makefile @@ -0,0 +1,69 @@ +all: rest-server-example coap-client-example + +CONTIKI=../.. +CFLAGS += -DPROJECT_CONF_H=\"project-conf.h\" + +# for static routing, if enabled +ifneq ($(TARGET), minimal-net) +PROJECT_SOURCEFILES += static-routing.c +endif + +# variable for root Makefile.include +WITH_UIP6=1 +# for some platforms +UIP_CONF_IPV6=1 + +# variable for this Makefile +# configure CoAP implementation (3|6|7) +WITH_COAP=7 + +# must be CFLAGS not variables +# minimal-net does not support RPL, avoid redefine warnings +ifneq ($(TARGET), minimal-net) +CFLAGS += -DUIP_CONF_IPV6_RPL=1 +endif + +# linker optimizations +CFLAGS += -ffunction-sections +LDFLAGS += -Wl,--gc-sections,--undefined=_reset_vector__,--undefined=InterruptVectors,--undefined=_copy_data_init__,--undefined=_clear_bss_init__,--undefined=_end_of_init__ + +# REST framework, requires WITH_COAP +ifeq ($(WITH_COAP), 7) +${info INFO: compiling with CoAP-07} +CFLAGS += -DWITH_COAP=7 +CFLAGS += -DREST=coap_rest_implementation +CFLAGS += -DUIP_CONF_TCP=0 +APPS += er-coap-07 +else ifeq ($(WITH_COAP), 6) +${info INFO: compiling with CoAP-06} +CFLAGS += -DWITH_COAP=6 +CFLAGS += -DREST=coap_rest_implementation +CFLAGS += -DUIP_CONF_TCP=0 +APPS += er-coap-06 +else ifeq ($(WITH_COAP), 3) +${info INFO: compiling with CoAP-03} +CFLAGS += -DWITH_COAP=3 +CFLAGS += -DREST=coap_rest_implementation +CFLAGS += -DUIP_CONF_TCP=0 +APPS += er-coap-03 +else +${info INFO: compiling with HTTP} +CFLAGS += -DWITH_HTTP +CFLAGS += -DREST=http_rest_implementation +CFLAGS += -DUIP_CONF_TCP=1 +APPS += rest-http-engine +endif + +APPS += erbium + + +include $(CONTIKI)/Makefile.include + +$(CONTIKI)/tools/tunslip6: $(CONTIKI)/tools/tunslip6.c + (cd $(CONTIKI)/tools && $(MAKE) tunslip6) + +connect-router: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 aaaa::1/64 + +connect-router-cooja: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 -a 127.0.0.1 aaaa::1/64 diff --git a/examples/er-rest-example/README b/examples/er-rest-example/README new file mode 100644 index 000000000..9a59cd8e9 --- /dev/null +++ b/examples/er-rest-example/README @@ -0,0 +1,67 @@ +This is the new example for the Erbium REST Engine +================================================== + +EXAMPLE FILES +------------- +rest-server-example.c: A RESTful server example showing how to use the REST layer to develop server-side applications (at the moment only CoAP is implemented for the REST Engine). +coap-client-example.c: A CoAP client that polls the /toggle resource every 10 seconds and cycles through 4 resources on button press (target address is hard-coded). + +PRELIMINARIES +------------- +a) For convenience, define the Cooja addresses in /etc/hosts + aaaa::0212:7401:0001:0101 cooja1 + aaaa::0212:7402:0002:0202 cooja2 + ... +b) Get the Copper CoAP browser from https://addons.mozilla.org/en-US/firefox/addon/copper-270430/ +c) Optional: Save Tmotes as default target + $ make TARGET=sky savetarget + +COOJA HOWTO +----------- +Server only: +1) $ make TARGET=cooja rest-server-example.csc +2) Open new terminal +3) $ make connect-router-cooja +4) Start Copper and discover resources at coap://cooja2:5683/ + +With client: +1) $ make TARGET=cooja coap-client-server-example.csc +2) Wait until red LED toggles on mote 2 (server) +3) Choose "Click button on Sky 3" from the context menu of mote 3 (client) and watch serial output + +TMOTES HOWTO +------------ +Server: +1) Connect two Tmote Skys (check with $ make TARGET=sky sky-motelist) +2) $ make TARGET=sky rest-server-example.upload MOTE=2 +3) $ make TARGET=sky login MOTE=2 +4) Press reset button, get address, abort with Ctrl+C: + Line: "Tentative link-local IPv6 address fe80:0000:0000:0000:____:____:____:____" +5) $ cd ../ipv6/rpl-border-router/ +6) $ make TARGET=sky border-router.upload MOTE=1 +7) $ make connect-router + For a BR tty other than USB0: $ make connect-router-port PORT=X +8) Start Copper and discover resources at coap://[aaaa::____:____:____:____]:5683/ + +Add a client: +1) Change the hard-coded server address in coap-client-example.c to aaaa::____:____:____:____ +2) Connect a third Tmote Sky +3) $ make TARGET=sky coap-client-example.upload MOTE=3 + +DETAILS +------- +The Erbium CoAP currently implements draft 07. +Central features are commented in rest-server-example.c. +In general, apps/er-coap-07 supports: +* All CoAP-07 header options +* CON Retransmissions (note COAP_MAX_OPEN_TRANSACTIONS) +* Blockwise Transfers (note REST_MAX_CHUNK_SIZE) +* Separate Responses (see rest_set_pre_handler() and coap_separate_handler()) +* Resource discovery +* Observing Resources (see EVENT_ and PRERIODIC_RESOURCE, note COAP_MAX_OBSERVERS) + +TODOs +----- +* Blockwise uploads (for POST/PUT payload) +* Multiple If-Match ETags +* (Message deduplication) diff --git a/examples/er-rest-example/coap-client-example.c b/examples/er-rest-example/coap-client-example.c new file mode 100644 index 000000000..6fb39eb48 --- /dev/null +++ b/examples/er-rest-example/coap-client-example.c @@ -0,0 +1,174 @@ +/* + * Copyright (c) 2011, Matthias Kovatsch and other contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * CoAP client example + * \author + * Matthias Kovatsch + */ + +#include +#include +#include + +#include "contiki.h" +#include "contiki-net.h" + +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) +#warning "Compiling with static routing!" +#include "static-routing.h" +#endif + +#include "dev/button-sensor.h" + +#if WITH_COAP == 3 +#include "er-coap-03-engine.h" +#elif WITH_COAP == 6 +#include "er-coap-06-engine.h" +#elif WITH_COAP == 7 +#include "er-coap-07-engine.h" +#else +#error "CoAP version defined by WITH_COAP not implemented" +#endif + + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +/* TODO: This server address is hard-coded for Cooja. */ +#define SERVER_NODE(ipaddr) uip_ip6addr(ipaddr, 0xfe80, 0, 0, 0, 0x0212, 0x7402, 0x0002, 0x0202) /* cooja2 */ + +#define LOCAL_PORT UIP_HTONS(COAP_DEFAULT_PORT+1) +#define REMOTE_PORT UIP_HTONS(COAP_DEFAULT_PORT) + +#define TOGGLE_INTERVAL 10 + +PROCESS(coap_client_example, "COAP Client Example"); +AUTOSTART_PROCESSES(&coap_client_example); + + +uip_ipaddr_t server_ipaddr; +static struct etimer et; + +/* Example URIs that can be queried. */ +#define NUMBER_OF_URLS 4 +char* service_urls[NUMBER_OF_URLS] = {".well-known/core", "/toggle", "battery/", "error/in//path"}; +#if PLATFORM_HAS_BUTTON +static int uri_switch = 0; +#endif + +/* This function is will be passed to COAP_BLOCKING_REQUEST() to handle responses. */ +void +client_chunk_handler(void *response) +{ + const uint8_t *chunk; + int len = coap_get_payload(response, &chunk); + printf("|%.*s", len, (char *)chunk); +} + + +PROCESS_THREAD(coap_client_example, ev, data) +{ + PROCESS_BEGIN(); + + static coap_packet_t request[1]; /* This way the packet can be treated as pointer as usual. */ + SERVER_NODE(&server_ipaddr); + + /* receives all CoAP messages */ + coap_receiver_init(); + + etimer_set(&et, TOGGLE_INTERVAL * CLOCK_SECOND); + +#if PLATFORM_HAS_BUTTON + SENSORS_ACTIVATE(button_sensor); + printf("Press a button to request %s\n", service_urls[uri_switch]); +#endif + + while(1) { + PROCESS_YIELD(); + + if (etimer_expired(&et)) { + printf("--Toggle timer--\n"); + +#if PLATFORM_HAS_LEDS + /* prepare request, TID is set by COAP_BLOCKING_REQUEST() */ + coap_init_message(request, COAP_TYPE_CON, COAP_POST, 0 ); + coap_set_header_uri_path(request, service_urls[1]); + coap_set_payload(request, (uint8_t *)"Toggle!", 8); +#else + /* prepare request, TID is set by COAP_BLOCKING_REQUEST() */ + coap_init_message(request, COAP_TYPE_CON, COAP_GET, 0 ); + coap_set_header_uri_path(request, "hello"); +#endif + + PRINT6ADDR(&server_ipaddr); + PRINTF(" : %u\n", UIP_HTONS(REMOTE_PORT)); + + COAP_BLOCKING_REQUEST(&server_ipaddr, REMOTE_PORT, request, client_chunk_handler); + + printf("\n--Done--\n"); + + etimer_reset(&et); + +#if PLATFORM_HAS_BUTTON + } else if (ev == sensors_event && data == &button_sensor) { + + /* send a request to notify the end of the process */ + + coap_init_message(request, COAP_TYPE_CON, COAP_GET, 0); + coap_set_header_uri_path(request, service_urls[uri_switch]); + + printf("--Requesting %s--\n", service_urls[uri_switch]); + + PRINT6ADDR(&server_ipaddr); + PRINTF(" : %u\n", UIP_HTONS(REMOTE_PORT)); + + COAP_BLOCKING_REQUEST(&server_ipaddr, REMOTE_PORT, request, client_chunk_handler); + + printf("\n--Done--\n"); + + uri_switch = (uri_switch+1) % NUMBER_OF_URLS; +#endif + + } + } + + PROCESS_END(); +} diff --git a/examples/er-rest-example/coap-client-server-example.csc b/examples/er-rest-example/coap-client-server-example.csc new file mode 100644 index 000000000..583dd8af4 --- /dev/null +++ b/examples/er-rest-example/coap-client-server-example.csc @@ -0,0 +1,227 @@ + + + [CONTIKI_DIR]/tools/cooja/apps/mrm + [CONTIKI_DIR]/tools/cooja/apps/mspsim + [CONTIKI_DIR]/tools/cooja/apps/avrora + [CONTIKI_DIR]/tools/cooja/apps/serial_socket + [CONTIKI_DIR]/tools/cooja/apps/collect-view + + REST with RPL router + -2147483648 + 123456 + 1000000 + + se.sics.cooja.radiomediums.UDGM + 50.0 + 50.0 + 1.0 + 1.0 + + + 40000 + + + se.sics.cooja.mspmote.SkyMoteType + rplroot + Sky RPL Root + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.c + make border-router.sky TARGET=sky + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + se.sics.cooja.mspmote.SkyMoteType + skyweb + CoAP Server + [CONTIKI_DIR]/examples/er-rest-example/rest-server-example.c + make rest-server-example.sky TARGET=sky + [CONTIKI_DIR]/examples/er-rest-example/rest-server-example.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + se.sics.cooja.mspmote.SkyMoteType + sky1 + CoAP Client + [CONTIKI_DIR]/examples/er-rest-example/coap-client-example.c + make coap-client-example.sky TARGET=sky + [CONTIKI_DIR]/examples/er-rest-example/coap-client-example.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + + + se.sics.cooja.interfaces.Position + 33.260163187353555 + 30.643217359962595 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 1 + + rplroot + + + + + se.sics.cooja.interfaces.Position + 46.57186415376375 + 40.35946215910942 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 2 + + skyweb + + + + + se.sics.cooja.interfaces.Position + 18.638049428485125 + 47.55034515769599 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 3 + + sky1 + + + + se.sics.cooja.plugins.SimControl + 259 + 0 + 179 + 0 + 0 + + + se.sics.cooja.plugins.Visualizer + + se.sics.cooja.plugins.skins.IDVisualizerSkin + se.sics.cooja.plugins.skins.UDGMVisualizerSkin + se.sics.cooja.plugins.skins.MoteTypeVisualizerSkin + se.sics.cooja.plugins.skins.AttributeVisualizerSkin + se.sics.cooja.plugins.skins.LEDVisualizerSkin + se.sics.cooja.plugins.skins.AddressVisualizerSkin + 3.61568947862321 0.0 0.0 3.61568947862321 15.610600779367 -85.92728269158351 + + 300 + 2 + 178 + 261 + 1 + + + se.sics.cooja.plugins.LogListener + + + + + 762 + 3 + 491 + 2 + 182 + + + se.sics.cooja.plugins.RadioLogger + + 150 + + + 451 + -1 + 305 + 73 + 140 + true + + + SerialSocketServer + 0 + 422 + 4 + 74 + 578 + 18 + + + se.sics.cooja.plugins.TimeLine + + 0 + 1 + 2 + + + + + 125 + 25.49079397896416 + + 1624 + 5 + 252 + 6 + 712 + + + se.sics.cooja.plugins.MoteInterfaceViewer + 2 + + Serial port + 0,0 + + 853 + 1 + 491 + 765 + 182 + + + diff --git a/examples/er-rest-example/project-conf.h b/examples/er-rest-example/project-conf.h new file mode 100644 index 000000000..f1c94e750 --- /dev/null +++ b/examples/er-rest-example/project-conf.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2010, Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * + */ + +#ifndef __PROJECT_RPL_WEB_CONF_H__ +#define __PROJECT_RPL_WEB_CONF_H__ + +#define SICSLOWPAN_CONF_FRAG 1 + +#ifndef QUEUEBUF_CONF_NUM +#define QUEUEBUF_CONF_NUM 6 +#endif + +/* Increase rpl-border-router IP-buffer when using 128 */ +#ifndef REST_MAX_CHUNK_SIZE +#define REST_MAX_CHUNK_SIZE 64 +#endif + +/* Decrease to 2 if no space left for stack when using 128-byte chunks */ +#ifndef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 4 +#endif + +/* Must be <= open transaction number */ +#ifndef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS COAP_MAX_OPEN_TRANSACTIONS +#endif + + +#ifndef UIP_CONF_RECEIVE_WINDOW +#define UIP_CONF_RECEIVE_WINDOW 60 +#endif + +#ifndef WEBSERVER_CONF_CFS_CONNS +#define WEBSERVER_CONF_CFS_CONNS 2 +#endif + +#endif /* __PROJECT_RPL_WEB_CONF_H__ */ diff --git a/examples/er-rest-example/rest-server-example.c b/examples/er-rest-example/rest-server-example.c new file mode 100644 index 000000000..846211169 --- /dev/null +++ b/examples/er-rest-example/rest-server-example.c @@ -0,0 +1,594 @@ +/* + * Copyright (c) 2011, Matthias Kovatsch and other contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Example for the CoAP REST Engine + * \author + * Matthias Kovatsch + */ + +#include +#include +#include +#include "contiki.h" +#include "contiki-net.h" + +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) +#warning "Compiling with static routing!" +#include "static-routing.h" +#endif + +#include "erbium.h" + + +#if defined (PLATFORM_HAS_BUTTON) +#include "dev/button-sensor.h" +#endif +#if defined (PLATFORM_HAS_LEDS) +#include "dev/leds.h" +#endif +#if defined (PLATFORM_HAS_LIGHT) +#include "dev/light-sensor.h" +#endif +#if defined (PLATFORM_HAS_BATTERY) +#include "dev/battery-sensor.h" +#endif +#if defined (PLATFORM_HAS_SHT11) +#include "dev/sht11-sensor.h" +#endif + + +/* For CoAP-specific example: not required for normal RESTful Web service. */ +#if WITH_COAP == 3 +#include "er-coap-03.h" +#elif WITH_COAP == 6 +#include "er-coap-06.h" +#elif WITH_COAP == 7 +#include "er-coap-07.h" +#else +#warning "REST example without CoAP" +#endif /* CoAP-specific example */ + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +/* + * Resources are defined by the RESOURCE macro. + * Signature: resource name, the RESTful methods it handles, and its URI path (omitting the leading slash). + */ +RESOURCE(helloworld, METHOD_GET, "hello", "title=\"Hello world (set length with ?len query)\";rt=\"Text\""); + +/* + * A handler function named [resource name]_handler must be implemented for each RESOURCE. + * A buffer for the response payload is provided through the buffer pointer. Simple resources can ignore + * preferred_size and offset, but must respect the REST_MAX_CHUNK_SIZE limit for the buffer. + * If a smaller block size is requested for CoAP, the REST framework automatically splits the data. + */ +void +helloworld_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + const char *len = NULL; + int length = 12; /* ------->| */ + char *message = "Hello World! ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789?!at 86 now+2+4at 99 now100..105..110..115..120..125..130..135..140..145..150..155..160"; + + /* The query string can be retrieved by rest_get_query() or parsed for its key-value pairs. */ + if (REST.get_query_variable(request, "len", &len)) { + length = atoi(len); + if (length<0) length = 0; + if (length>REST_MAX_CHUNK_SIZE) length = REST_MAX_CHUNK_SIZE; + memcpy(buffer, message, length); + } else { + memcpy(buffer, message, length); + } + + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); /* text/plain is the default, hence this option could be omitted. */ + REST.set_header_etag(response, (uint8_t *) &length, 1); + REST.set_response_payload(response, buffer, length); +} + +/* This resource mirrors the incoming request. It shows how to access the options and how to set them for the response. */ +RESOURCE(mirror, METHOD_GET | METHOD_POST | METHOD_PUT | METHOD_DELETE | HAS_SUB_RESOURCES, "mirror", "title=\"Returns your decoded message\";rt=\"Debug\""); + +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 and should be static or in program memory (char *str = "string in .text";). + * They must be '\0'-terminated as the setters use strlen(). */ + 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 = 0; + const char *str = ""; + 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. + * Add +1 to fill the complete buffer. + * The additional byte is taken care of by allocating REST_MAX_CHUNK_SIZE+1 bytes in the REST framework. */ + 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 (REST.get_header_max_age(request, &max_age)) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "MA %lu\n", max_age); + } + if ((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 (coap_get_header_observe(request, &observe)) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Ob %lu\n", observe); + } + if ((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= 5 + if ((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 ((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 (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); + } + if (coap_get_header_block1(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, "B1 %lu%s (%u)\n", block_num, block_more ? "+" : "", block_size); + } +#if WITH_COAP >= 7 + +#endif + +#endif +#endif /* CoAP-specific example */ + + if ((len = REST.get_query(request, &query))) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Qu %.*s\n", len, query); + } + if ((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, 10); /* For HTTP, browsers will not re-request the page for 10 seconds. CoAP action depends on the client. */ + REST.set_header_etag(response, opaque, 2); + REST.set_header_location(response, location); /* Initial slash is omitted by framework */ + +/* 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. */ +#elif WITH_COAP >= 5 + 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); +#if WITH_COAP >= 7 + coap_set_header_accept(response, TEXT_PLAIN); + coap_set_header_if_none_match(response); +#endif + +#endif +#endif /* CoAP-specific example */ +} + +/* + * For data larger than REST_MAX_CHUNK_SIZE (e.g., stored in flash) resources must be aware of the buffer limitation + * and split their responses by themselves. To transfer the complete resource through a TCP stream or CoAP's blockwise transfer, + * the byte offset where to continue is provided to the handler as int32_t pointer. + * These chunk-wise resources must set the offset value to its new position or -1 of the end is reached. + * (The offset for CoAP's blockwise transfer can go up to 2'147'481'600 = ~2047 M for block size 2048 (reduced to 1024 in observe-03.) + */ +RESOURCE(chunks, METHOD_GET, "chunks", "title=\"Blockwise demo\";rt=\"Data\""); + +#define CHUNKS_TOTAL 1030 + +void +chunks_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + int32_t strpos = 0; + + /* Check the offset for boundaries of the resource data. */ + if (*offset>=CHUNKS_TOTAL) + { + REST.set_response_status(response, REST.status.BAD_OPTION); + REST.set_response_payload(response, (uint8_t*)"Block out of scope", 18); + return; + } + + /* Generate data until reaching CHUNKS_TOTAL. */ + while (strpos CHUNKS_TOTAL) + { + strpos = CHUNKS_TOTAL - *offset; + } + + REST.set_response_payload(response, buffer, strpos); + + /* Signal chunk awareness of resource to framework. */ + *offset += strpos; + + /* Signal end of resource. */ + if (*offset>=CHUNKS_TOTAL) + { + *offset = -1; + } +} + +/* + * Example for a periodic resource. + * It takes an additional period parameter, which defines the interval to call [name]_periodic_handler(). + * A default post_handler takes care of subscriptions by managing a list of subscribers to notify. + */ +PERIODIC_RESOURCE(polling, METHOD_GET, "poll", "title=\"Periodic demo\";rt=\"Observable\"", 5*CLOCK_SECOND); + +void +polling_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + REST.set_response_payload(response, (uint8_t *)"It's periodic!", 14); + + /* A post_handler that handles subscriptions will be called for periodic resources by the REST framework. */ +} + +/* + * Additionally, a handler function named [resource name]_handler must be implemented for each PERIODIC_RESOURCE. + * It will be called by the REST manager process with the defined period. + */ +int +polling_periodic_handler(resource_t *r) +{ + static uint32_t periodic_i = 0; + static char content[16]; + + PRINTF("TICK /%s\n", r->url); + periodic_i = periodic_i + 1; + + /* Notify the registered observers with the given message type, observe option, and payload. */ + REST.notify_subscribers(r->url, 1, periodic_i, (uint8_t *)content, snprintf(content, sizeof(content), "TICK %lu", periodic_i)); + /* |-> implementation-specific, e.g. CoAP: 1=CON and 0=NON notification */ + + return 1; +} + +#if defined (PLATFORM_HAS_BUTTON) +/* + * Example for an event resource. + * Additionally takes a period parameter that defines the interval to call [name]_periodic_handler(). + * A default post_handler takes care of subscriptions and manages a list of subscribers to notify. + */ +EVENT_RESOURCE(event, METHOD_GET, "event", "title=\"Event demo\";rt=\"Observable\""); + +void +event_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + REST.set_response_payload(response, (uint8_t *)"It's eventful!", 14); + + /* A post_handler that handles subscriptions/observing will be called for periodic resources by the framework. */ +} + +/* Additionally, a handler function named [resource name]_event_handler must be implemented for each PERIODIC_RESOURCE defined. + * It will be called by the REST manager process with the defined period. */ +int +event_event_handler(resource_t *r) +{ + static uint32_t event_i = 0; + static char content[10]; + + PRINTF("EVENT /%s\n", r->url); + ++event_i; + + /* Notify registered observers with the given message type, observe option, and payload. + * The token will be set automatically. */ + + // FIXME provide a rest_notify_subscribers call; how to manage specific options such as COAP_TYPE? + REST.notify_subscribers(r->url, 0, event_i, content, snprintf(content, sizeof(content), "EVENT %lu", event_i)); + return 1; +} +#endif /* PLATFORM_HAS_BUTTON */ + +#if defined (PLATFORM_HAS_LEDS) +/*A simple actuator example, depending on the color query parameter and post variable mode, corresponding led is activated or deactivated*/ +RESOURCE(led, METHOD_POST | METHOD_PUT , "leds", "title=\"Led control (use ?color=red|green|blue and POST/PUT mode=on|off)\";rt=\"Control\""); + +void +led_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + size_t len = 0; + const char *color = NULL; + const char *mode = NULL; + uint8_t led = 0; + int success = 1; + + if ((len=REST.get_query_variable(request, "color", &color))) { + PRINTF("color %.*s\n", len, color); + + if (strncmp(color, "red", len)==0) { + led = LEDS_RED; + } else if(strncmp(color,"green", len)==0) { + led = LEDS_GREEN; + } else if (strncmp(color,"blue", len)==0) { + led = LEDS_BLUE; + } else { + success = 0; + } + } else { + success = 0; + } + + if (success && (len=REST.get_post_variable(request, "mode", &mode))) { + PRINTF("mode %s\n", mode); + + if (strncmp(mode, "on", len)==0) { + leds_on(led); + } else if (strncmp(mode, "off", len)==0) { + leds_off(led); + } else { + success = 0; + } + } else { + success = 0; + } + + if (!success) { + REST.set_response_status(response, REST.status.BAD_REQUEST); + } +} + +/* A simple actuator example. Toggles the red led */ +RESOURCE(toggle, METHOD_GET | METHOD_PUT | METHOD_POST, "toggle", "title=\"Red LED\";rt=\"Control\""); +void +toggle_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + leds_toggle(LEDS_RED); +} +#endif /* PLATFORM_HAS_LEDS */ + +#if defined (PLATFORM_HAS_LIGHT) +/* A simple getter example. Returns the reading from light sensor with a simple etag */ +RESOURCE(light, METHOD_GET, "light", "title=\"Photosynthetic and solar light (supports JSON)\";rt=\"LightSensor\""); +void +light_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + uint16_t light_photosynthetic = light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC); + uint16_t light_solar = light_sensor.value(LIGHT_SENSOR_TOTAL_SOLAR); + + uint16_t *accept = NULL; + int num = REST.get_header_accept(request, &accept); + + if ((num==0) || (num && accept[0]==REST.type.TEXT_PLAIN)) + { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf(buffer, REST_MAX_CHUNK_SIZE, "%u;%u", light_photosynthetic, light_solar); + + REST.set_response_payload(response, (uint8_t *)buffer, strlen(buffer)); + } + else if (num && (accept[0]==REST.type.APPLICATION_XML)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_XML); + snprintf(buffer, REST_MAX_CHUNK_SIZE, "", light_photosynthetic, light_solar); + + REST.set_response_payload(response, buffer, strlen(buffer)); + } + else if (num && (accept[0]==REST.type.APPLICATION_JSON)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf(buffer, REST_MAX_CHUNK_SIZE, "{'light':{'photosynthetic':%u,'solar':%u}}", light_photosynthetic, light_solar); + + REST.set_response_payload(response, buffer, strlen(buffer)); + } + else + { + REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE); + REST.set_response_payload(response, (uint8_t *)"Supporting content-types text/plain, application/xml, and application/json", 74); + } +} +#endif /* PLATFORM_HAS_LIGHT */ + +#if defined (PLATFORM_HAS_BATTERY) +/* A simple getter example. Returns the reading from light sensor with a simple etag */ +RESOURCE(battery, METHOD_GET, "battery", "title=\"Battery status\";rt=\"Battery\""); +void +battery_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + int battery = battery_sensor.value(0); + + uint16_t *accept = NULL; + int num = REST.get_header_accept(request, &accept); + + if ((num==0) || (num && accept[0]==REST.type.TEXT_PLAIN)) + { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf(buffer, REST_MAX_CHUNK_SIZE, "%d", battery); + + REST.set_response_payload(response, (uint8_t *)buffer, strlen(buffer)); + } + else if (num && (accept[0]==REST.type.APPLICATION_JSON)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf(buffer, REST_MAX_CHUNK_SIZE, "{'battery':%d}", battery); + + REST.set_response_payload(response, buffer, strlen(buffer)); + } + else + { + REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE); + REST.set_response_payload(response, (uint8_t *)"Supporting content-types text/plain and application/json", 56); + } +} +#endif /* PLATFORM_HAS_BATTERY */ + + +PROCESS(rest_server_example, "Rest Server Example"); +AUTOSTART_PROCESSES(&rest_server_example); + +PROCESS_THREAD(rest_server_example, ev, data) +{ + PROCESS_BEGIN(); + + PRINTF("Rest Example\n"); + +#ifdef RF_CHANNEL + PRINTF("RF channel: %u\n", RF_CHANNEL); +#endif +#ifdef IEEE802154_PANID + PRINTF("PAN ID: 0x%04X\n", IEEE802154_PANID); +#endif + + PRINTF("uIP buffer: %u\n", UIP_BUFSIZE); + PRINTF("LL header: %u\n", UIP_LLH_LEN); + PRINTF("IP+UDP header: %u\n", UIP_IPUDPH_LEN); + PRINTF("REST max chunk: %u\n", REST_MAX_CHUNK_SIZE); + +/* if static routes are used rather than RPL */ +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) + set_global_address(); + configure_routing(); +#endif + + /* Initialize the REST framework. */ + rest_init_framework(); + + /* Activate the application-specific resources. */ + rest_activate_resource(&resource_helloworld); + rest_activate_resource(&resource_mirror); + rest_activate_resource(&resource_chunks); + rest_activate_periodic_resource(&periodic_resource_polling); + +#if defined (PLATFORM_HAS_BUTTON) + SENSORS_ACTIVATE(button_sensor); + rest_activate_event_resource(&resource_event); +#endif +#if defined (PLATFORM_HAS_LEDS) + rest_activate_resource(&resource_led); + rest_activate_resource(&resource_toggle); +#endif /* PLATFORM_HAS_LEDS */ +#if defined (PLATFORM_HAS_LIGHT) + SENSORS_ACTIVATE(light_sensor); + rest_activate_resource(&resource_light); +#endif +#if defined (PLATFORM_HAS_BATTERY) + SENSORS_ACTIVATE(battery_sensor); + rest_activate_resource(&resource_battery); +#endif + + /* Define application-specific events here. */ + while(1) { + PROCESS_WAIT_EVENT(); +#if defined (PLATFORM_HAS_BUTTON) + if (ev == sensors_event && data == &button_sensor) { + PRINTF("BUTTON\n"); + /* Call the event_handler for this application-specific event. */ + event_event_handler(&resource_event); + } +#endif /* PLATFORM_HAS_BUTTON */ + } /* while (1) */ + + PROCESS_END(); +} diff --git a/examples/er-rest-example/rest-server-example.csc b/examples/er-rest-example/rest-server-example.csc new file mode 100644 index 000000000..de5c85fa8 --- /dev/null +++ b/examples/er-rest-example/rest-server-example.csc @@ -0,0 +1,188 @@ + + + [CONTIKI_DIR]/tools/cooja/apps/mrm + [CONTIKI_DIR]/tools/cooja/apps/mspsim + [CONTIKI_DIR]/tools/cooja/apps/avrora + [CONTIKI_DIR]/tools/cooja/apps/serial_socket + [CONTIKI_DIR]/tools/cooja/apps/collect-view + + REST with RPL router + -2147483648 + 123456 + 1000000 + + se.sics.cooja.radiomediums.UDGM + 50.0 + 50.0 + 1.0 + 1.0 + + + 40000 + + + se.sics.cooja.mspmote.SkyMoteType + rplroot + Sky RPL Root + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.c + make border-router.sky TARGET=sky + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + se.sics.cooja.mspmote.SkyMoteType + skyweb + Rest + [CONTIKI_DIR]/examples/rest-example/rest-server-example.c + make rest-server-example.sky TARGET=sky + [CONTIKI_DIR]/examples/rest-example/rest-server-example.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + + + se.sics.cooja.interfaces.Position + 33.260163187353555 + 30.643217359962595 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 1 + + rplroot + + + + + se.sics.cooja.interfaces.Position + 35.100895239785295 + 39.70574552287428 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 2 + + skyweb + + + + se.sics.cooja.plugins.SimControl + 259 + 1 + 179 + 0 + 0 + + + se.sics.cooja.plugins.Visualizer + + se.sics.cooja.plugins.skins.IDVisualizerSkin + se.sics.cooja.plugins.skins.UDGMVisualizerSkin + se.sics.cooja.plugins.skins.MoteTypeVisualizerSkin + se.sics.cooja.plugins.skins.AttributeVisualizerSkin + se.sics.cooja.plugins.skins.LEDVisualizerSkin + se.sics.cooja.plugins.skins.AddressVisualizerSkin + 7.9849281638410705 0.0 0.0 7.9849281638410705 -133.27812697619663 -225.04752569190535 + + 300 + 0 + 175 + 371 + 2 + + + se.sics.cooja.plugins.LogListener + + + + 762 + 3 + 326 + 12 + 294 + + + se.sics.cooja.plugins.RadioLogger + + 150 + + + 451 + -1 + 305 + 73 + 140 + true + + + SerialSocketServer + 0 + 422 + 5 + 74 + 1234 + 93 + + + se.sics.cooja.plugins.TimeLine + + 0 + 1 + + + + + 125 + 25.49079397896416 + + 1624 + 4 + 252 + 166 + 699 + + + se.sics.cooja.plugins.MoteInterfaceViewer + 1 + + Serial port + 0,0 + + 662 + 2 + 362 + 7 + 221 + + + diff --git a/examples/er-rest-example/static-routing.c b/examples/er-rest-example/static-routing.c new file mode 100644 index 000000000..c2f0e3a25 --- /dev/null +++ b/examples/er-rest-example/static-routing.c @@ -0,0 +1,155 @@ +/* + * static-routing.c + * + * Created on: Oct 12, 2010 + * Author: simonduq + */ + +#include +#include "static-routing.h" + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF(" %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x ", ((u8_t *)addr)[0], ((u8_t *)addr)[1], ((u8_t *)addr)[2], ((u8_t *)addr)[3], ((u8_t *)addr)[4], ((u8_t *)addr)[5], ((u8_t *)addr)[6], ((u8_t *)addr)[7], ((u8_t *)addr)[8], ((u8_t *)addr)[9], ((u8_t *)addr)[10], ((u8_t *)addr)[11], ((u8_t *)addr)[12], ((u8_t *)addr)[13], ((u8_t *)addr)[14], ((u8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF(" %02x:%02x:%02x:%02x:%02x:%02x ",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +#include "contiki-net.h" +#include "node-id.h" + +int node_rank; + +struct id_to_addrs { + int id; + uint32_t addr; +}; + +const struct id_to_addrs motes_addrs[] = { +/* + * Static routing requires a map nodeid => address. + * The nodeid can be programmed with the sky-shell. + * The addresses should also be added to /etc/hosts. + * + * aaaa::212:7400:1160:f62d sky1 + * aaaa::212:7400:0da0:d748 sky2 + * aaaa::212:7400:116e:c325 sky3 + * aaaa::212:7400:116e:c444 sky4 + * aaaa::212:7400:115e:b717 sky5 + * + * Add the nodeid and last 4 bytes of the address to the map. + */ + {1, 0x1160f62d}, + {2, 0x0da0d748}, + {3, 0x116ec325}, + {4, 0x116ec444}, + {5, 0x115eb717}, +}; +/* Define the size of the map. */ +#define NODES_IN_MAP 5 + +uint32_t get_mote_suffix(int rank) { + if(--rank >=0 && rank<(sizeof(motes_addrs)/sizeof(struct id_to_addrs))) { + return motes_addrs[rank].addr; + } + return 0; +} + +int get_mote_id(uint32_t suffix) { +#if IN_COOJA + return suffix & 0xff; +#else + int i; + for(i=0; i<(sizeof(motes_addrs)/sizeof(struct id_to_addrs)); i++) { + if(suffix == motes_addrs[i].addr) { + return motes_addrs[i].id; + } + } + return 0; +#endif +} + +void set_global_address(void) { + uip_ipaddr_t ipaddr; + + uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); + uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); + uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); +} + +static void add_route_ext(int dest, int next) { + PRINTF("add route ext %d %d\n", dest, next); + uip_ipaddr_t ipaddr_dest, ipaddr_next; + uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0, 0, 0, dest); +#if IN_COOJA + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400 | next, next, next<<8 | next); +#else + uint32_t next_suffix = get_mote_suffix(next); + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400, (next_suffix >> 16) & 0xffff, next_suffix & 0xffff); +#endif + uip_ds6_route_add(&ipaddr_dest, 128, &ipaddr_next, 0); +} + +void add_route(int dest, int next) { + PRINTF("add route %d %d\n", dest, next); + uip_ipaddr_t ipaddr_dest, ipaddr_next; +#if IN_COOJA + uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0x0212, 0x7400 | dest, dest, dest<<8 | dest); + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400 | next, next, next<<8 | next); +#else + uint32_t dest_suffix = get_mote_suffix(dest); + uint32_t next_suffix = get_mote_suffix(next); + uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0x0212, 0x7400, (dest_suffix >> 16) & 0xffff, dest_suffix & 0xffff); + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400, (next_suffix >> 16) & 0xffff, next_suffix & 0xffff); +#endif + uip_ds6_route_add(&ipaddr_dest, 128, &ipaddr_next, 0); +} + +void configure_routing(void) { + int i; +#if IN_COOJA + node_rank = node_id; +#else + node_rank = -1; + for(i=0; i<(sizeof(motes_addrs)/sizeof(struct id_to_addrs)); ++i) { + if(node_id == motes_addrs[i].id) { + node_rank = i+1; + break; + } + } + + if(node_rank == -1) { + printf("unable to configure routing, node_id=%d\n", node_id); + return; + } +#endif + + printf("configure_routing, node_id=%d, node_rank %d\n", node_id, node_rank); + + if (node_rank == 1) { /* border router #1 */ + add_route_ext(2, 2); + for(i=2; i<=NODES_IN_MAP; ++i) { + add_route(i, 2); + } + } else if (node_rank < NODES_IN_MAP) { /* other node */ + add_route_ext(1, node_rank-1); + add_route_ext(2, node_rank+1); + for(i=1; i<=NODES_IN_MAP; ++i) { + if(inode_rank) { + add_route(i, node_rank+1); + } + } + } else if (node_rank == NODES_IN_MAP) { /* 2nd border router */ + add_route_ext(1, NODES_IN_MAP-1); + for(i=1; i<=NODES_IN_MAP-1; ++i) { + add_route(i, NODES_IN_MAP-1); + } + } +} diff --git a/examples/er-rest-example/static-routing.h b/examples/er-rest-example/static-routing.h new file mode 100644 index 000000000..0dff0b7ba --- /dev/null +++ b/examples/er-rest-example/static-routing.h @@ -0,0 +1,20 @@ +/* + * static-routing.h + * + * Created on: Oct 12, 2010 + * Author: simonduq + */ + +#ifndef STATICROUTING_H_ +#define STATICROUTING_H_ + +#include "contiki.h" + +extern int node_rank; +extern uint32_t get_mote_suffix(int id); +extern int get_mote_id(uint32_t suffix); +extern void add_route(int dest, int next); +extern void set_global_address(void); +extern void configure_routing(void); + +#endif /* STATICROUTING_H_ */