2011-09-14 14:33:01 +00:00
/*
* 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 < kovatsch @ inf . ethz . ch >
*/
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include "contiki.h"
# include "contiki-net.h"
2012-01-12 19:19:54 +00:00
/* Define which resources to include to meet memory constraints. */
# define REST_RES_HELLO 1
2012-01-20 15:11:45 +00:00
# define REST_RES_MIRROR 0 /* causes largest code size */
2012-01-12 19:19:54 +00:00
# define REST_RES_CHUNKS 1
2012-01-31 03:38:07 +00:00
# define REST_RES_SEPARATE 1
2012-02-01 02:24:49 +00:00
# define REST_RES_PUSHING 1
2012-01-12 19:19:54 +00:00
# define REST_RES_EVENT 1
2012-01-20 15:11:45 +00:00
# define REST_RES_LEDS 1
2012-01-12 19:19:54 +00:00
# define REST_RES_TOGGLE 1
2012-01-31 03:38:07 +00:00
# define REST_RES_LIGHT 0
2012-05-13 14:23:28 +00:00
# define REST_RES_BATTERY 0
2012-01-12 19:19:54 +00:00
2012-03-17 10:47:09 +00:00
# if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) && !defined (CONTIKI_TARGET_NATIVE)
2011-09-14 14:33:01 +00:00
# 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 == 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__)
2012-02-20 19:20:03 +00:00
# define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((uint8_t *)addr)[0], ((uint8_t *)addr)[1], ((uint8_t *)addr)[2], ((uint8_t *)addr)[3], ((uint8_t *)addr)[4], ((uint8_t *)addr)[5], ((uint8_t *)addr)[6], ((uint8_t *)addr)[7], ((uint8_t *)addr)[8], ((uint8_t *)addr)[9], ((uint8_t *)addr)[10], ((uint8_t *)addr)[11], ((uint8_t *)addr)[12], ((uint8_t *)addr)[13], ((uint8_t *)addr)[14], ((uint8_t *)addr)[15])
2011-09-14 14:33:01 +00:00
# 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
2012-01-12 19:19:54 +00:00
# if REST_RES_HELLO
2011-09-14 14:33:01 +00:00
/*
* Resources are defined by the RESOURCE macro .
* Signature : resource name , the RESTful methods it handles , and its URI path ( omitting the leading slash ) .
*/
2011-10-10 12:16:27 +00:00
RESOURCE ( helloworld , METHOD_GET , " hello " , " title= \" Hello world: ?len=0.. \" ;rt= \" Text \" " ) ;
2011-09-14 14:33:01 +00:00
/*
* 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 ;
2011-10-10 12:16:27 +00:00
/* Some data that has the length up to REST_MAX_CHUNK_SIZE. For more, see the chunk resource. */
char const * const message = " Hello World! ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxy " ;
int length = 12 ; /* |<-------->| */
2011-09-14 14:33:01 +00:00
/* 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 ) ;
}
2012-01-12 19:19:54 +00:00
# endif
2011-09-14 14:33:01 +00:00
2012-01-12 19:19:54 +00:00
# if REST_RES_MIRROR
2011-09-14 14:33:01 +00:00
/* This resource mirrors the incoming request. It shows how to access the options and how to set them for the response. */
2011-12-07 19:51:03 +00:00
RESOURCE ( mirror , METHOD_GET | METHOD_POST | METHOD_PUT | METHOD_DELETE , " debug/mirror " , " title= \" Returns your decoded message \" ;rt= \" Debug \" " ) ;
2011-09-14 14:33:01 +00:00
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 } ;
2012-01-31 03:38:07 +00:00
/* Strings are not copied, so use static string buffers or strings in .text memory (char *str = "string in .text";). */
2011-09-14 14:33:01 +00:00
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 ;
2012-01-28 17:52:14 +00:00
const char * str = NULL ;
2011-09-14 14:33:01 +00:00
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.
2012-01-20 15:11:45 +00:00
* The additional byte is taken care of by allocating REST_MAX_CHUNK_SIZE + 1 bytes in the REST framework .
* Add + 1 to fill the complete buffer . */
2011-09-14 14:33:01 +00:00
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 . */
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & REST . get_header_max_age ( request , & max_age ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " MA %lu \n " , max_age ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = REST . get_header_host ( request , & str ) ) )
2011-09-14 14:33:01 +00:00
{
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
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & coap_get_header_observe ( request , & observe ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " Ob %lu \n " , observe ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = coap_get_header_token ( request , & bytes ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " To 0x " ) ;
int index = 0 ;
for ( index = 0 ; index < len ; + + index ) {
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " %02X " , bytes [ index ] ) ;
}
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " \n " ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = coap_get_header_etag ( request , & bytes ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " ET 0x " ) ;
int index = 0 ;
for ( index = 0 ; index < len ; + + index ) {
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " %02X " , bytes [ index ] ) ;
}
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " \n " ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = coap_get_header_uri_path ( request , & str ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " UP " ) ;
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " %.*s \n " , len , str ) ;
}
# if WITH_COAP == 3
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = coap_get_header_location ( request , & str ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " Lo %.*s \n " , len , str ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & coap_get_header_block ( request , & block_num , & block_more , & block_size , NULL ) ) /* This getter allows NULL pointers to get only a subset of the block parameters. */
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " Bl %lu%s (%u) \n " , block_num , block_more ? " + " : " " , block_size ) ;
}
2012-01-20 17:30:12 +00:00
# else
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = coap_get_header_location_path ( request , & str ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " LP %.*s \n " , len , str ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = coap_get_header_location_query ( request , & str ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " LQ %.*s \n " , len , str ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & coap_get_header_block2 ( request , & block_num , & block_more , & block_size , NULL ) ) /* This getter allows NULL pointers to get only a subset of the block parameters. */
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " B2 %lu%s (%u) \n " , block_num , block_more ? " + " : " " , block_size ) ;
}
2012-01-20 17:30:12 +00:00
/*
* Critical Block1 option is currently rejected by engine .
*
if ( strpos < = REST_MAX_CHUNK_SIZE & & coap_get_header_block1 ( request , & block_num , & block_more , & block_size , NULL ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " B1 %lu%s (%u) \n " , block_num , block_more ? " + " : " " , block_size ) ;
}
2012-01-20 17:30:12 +00:00
*/
# endif /* CoAP > 03 */
2011-09-14 14:33:01 +00:00
# endif /* CoAP-specific example */
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = REST . get_query ( request , & query ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " Qu %.*s \n " , len , query ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos < = REST_MAX_CHUNK_SIZE & & ( len = REST . get_request_payload ( request , & bytes ) ) )
2011-09-14 14:33:01 +00:00
{
strpos + = snprintf ( ( char * ) buffer + strpos , REST_MAX_CHUNK_SIZE - strpos + 1 , " %.*s " , len , bytes ) ;
}
2012-01-20 15:11:45 +00:00
if ( strpos > = REST_MAX_CHUNK_SIZE )
2011-09-14 14:33:01 +00:00
{
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. */
2012-01-20 17:30:12 +00:00
# else
2011-09-14 14:33:01 +00:00
coap_set_header_proxy_uri ( response , " ftp://x " ) ;
coap_set_header_block2 ( response , 42 , 0 , 64 ) ; /* The block option might be overwritten by the framework when blockwise transfer is requested. */
coap_set_header_block1 ( response , 23 , 0 , 16 ) ;
coap_set_header_accept ( response , TEXT_PLAIN ) ;
coap_set_header_if_none_match ( response ) ;
2012-01-20 17:30:12 +00:00
# endif /* CoAP > 03 */
2011-09-14 14:33:01 +00:00
# endif /* CoAP-specific example */
}
2012-01-12 19:19:54 +00:00
# endif /* REST_RES_MIRROR */
2011-09-14 14:33:01 +00:00
2012-01-12 19:19:54 +00:00
# if REST_RES_CHUNKS
2011-09-14 14:33:01 +00:00
/*
* 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. )
*/
2011-12-07 19:51:03 +00:00
RESOURCE ( chunks , METHOD_GET , " debug/chunks " , " title= \" Blockwise demo \" ;rt= \" Data \" " ) ;
2011-09-14 14:33:01 +00:00
2011-10-10 12:16:27 +00:00
# define CHUNKS_TOTAL 2050
2011-09-14 14:33:01 +00:00
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 ) ;
2011-10-10 12:16:27 +00:00
/* A block error message should not exceed the minimum block size (16). */
2012-01-28 17:52:14 +00:00
2012-02-01 02:24:49 +00:00
const char * error_msg = " BlockOutOfScope " ;
REST . set_response_payload ( response , error_msg , strlen ( error_msg ) ) ;
2011-09-14 14:33:01 +00:00
return ;
}
/* Generate data until reaching CHUNKS_TOTAL. */
2011-10-10 14:09:17 +00:00
while ( strpos < preferred_size )
{
strpos + = snprintf ( ( char * ) buffer + strpos , preferred_size - strpos + 1 , " |%ld| " , * offset ) ;
2011-09-14 14:33:01 +00:00
}
2011-10-10 14:09:17 +00:00
/* snprintf() does not adjust return value if truncated by size. */
if ( strpos > preferred_size )
{
strpos = preferred_size ;
}
2012-01-20 15:11:45 +00:00
/* Truncate if above CHUNKS_TOTAL bytes. */
2011-10-10 14:09:17 +00:00
if ( * offset + ( int32_t ) strpos > CHUNKS_TOTAL )
2011-09-14 14:33:01 +00:00
{
strpos = CHUNKS_TOTAL - * offset ;
}
REST . set_response_payload ( response , buffer , strpos ) ;
2011-10-10 12:16:27 +00:00
/* IMPORTANT for chunk-wise resources: Signal chunk awareness to REST engine. */
2011-09-14 14:33:01 +00:00
* offset + = strpos ;
2011-10-10 14:09:17 +00:00
/* Signal end of resource representation. */
2011-09-14 14:33:01 +00:00
if ( * offset > = CHUNKS_TOTAL )
{
* offset = - 1 ;
}
}
2012-01-12 19:19:54 +00:00
# endif
2011-09-14 14:33:01 +00:00
2012-02-06 05:21:33 +00:00
# if defined (PLATFORM_HAS_BUTTON) && REST_RES_SEPARATE && WITH_COAP > 3
2012-01-31 03:38:07 +00:00
/* Required to manually (=not by the engine) handle the response transaction. */
# include "er-coap-07-separate.h"
# include "er-coap-07-transactions.h"
/*
* CoAP - specific example for separate responses .
2012-02-05 05:21:35 +00:00
* Note the call " rest_set_pre_handler(&resource_separate, coap_separate_handler); " in the main process .
* The pre - handler takes care of the empty ACK and updates the MID and message type for CON requests .
* The resource handler must store all information that required to finalize the response later .
2012-01-31 03:38:07 +00:00
*/
RESOURCE ( separate , METHOD_GET , " debug/separate " , " title= \" Separate demo \" " ) ;
2012-02-05 05:21:35 +00:00
/* A structure to store the required information */
typedef struct application_separate_store {
/* Provided by Erbium to store generic request information such as remote address and token. */
coap_separate_t request_metadata ;
/* Add fields for addition information to be stored for finalizing, e.g.: */
char buffer [ 16 ] ;
} application_separate_store_t ;
2012-01-31 03:38:07 +00:00
static uint8_t separate_active = 0 ;
2012-02-05 05:21:35 +00:00
static application_separate_store_t separate_store [ 1 ] ;
2012-01-31 03:38:07 +00:00
void
separate_handler ( void * request , void * response , uint8_t * buffer , uint16_t preferred_size , int32_t * offset )
{
/*
* Example allows only one open separate response .
* For multiple , the application must manage the list of stores .
*/
if ( separate_active )
{
2012-03-29 16:05:07 +00:00
coap_separate_reject ( ) ;
2012-01-31 03:38:07 +00:00
}
else
{
separate_active = 1 ;
/* Take over and skip response by engine. */
2012-03-29 16:05:07 +00:00
coap_separate_accept ( request , & separate_store - > request_metadata ) ;
2012-02-06 05:21:33 +00:00
/* Be aware to respect the Block2 option, which is also stored in the coap_separate_t. */
2012-01-31 03:38:07 +00:00
/*
* At the moment , only the minimal information is stored in the store ( client address , port , token , MID , type , and Block2 ) .
* Extend the store , if the application requires additional information from this handler .
* buffer is an example field for custom information .
*/
snprintf ( separate_store - > buffer , sizeof ( separate_store - > buffer ) , " StoredInfo " ) ;
}
}
void
separate_finalize_handler ( )
{
if ( separate_active )
{
coap_transaction_t * transaction = NULL ;
2012-02-05 05:21:35 +00:00
if ( ( transaction = coap_new_transaction ( separate_store - > request_metadata . mid , & separate_store - > request_metadata . addr , separate_store - > request_metadata . port ) ) )
2012-01-31 03:38:07 +00:00
{
coap_packet_t response [ 1 ] ; /* This way the packet can be treated as pointer as usual. */
2012-02-06 05:21:33 +00:00
/* Restore the request information for the response. */
coap_separate_resume ( response , & separate_store - > request_metadata , CONTENT_2_05 ) ;
2012-01-31 03:38:07 +00:00
coap_set_payload ( response , separate_store - > buffer , strlen ( separate_store - > buffer ) ) ;
2012-02-06 05:21:33 +00:00
/*
* Be aware to respect the Block2 option , which is also stored in the coap_separate_t .
* As it is a critical option , this example resource pretends to handle it for compliance .
*/
coap_set_header_block2 ( response , separate_store - > request_metadata . block2_num , 0 , separate_store - > request_metadata . block2_size ) ;
2012-01-31 03:38:07 +00:00
/* Warning: No check for serialization error. */
transaction - > packet_len = coap_serialize_message ( response , transaction - > packet ) ;
coap_send_transaction ( transaction ) ;
/* The engine will clear the transaction (right after send for NON, after acked for CON). */
separate_active = 0 ;
}
else
{
/*
* Set timer for retry , send error message , . . .
* The example simply waits for another button press .
*/
}
} /* if (separate_active) */
}
# endif
2012-02-01 02:24:49 +00:00
# if REST_RES_PUSHING
/*
* 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 .
*/
2012-03-17 15:51:28 +00:00
PERIODIC_RESOURCE ( pushing , METHOD_GET , " debug/push " , " title= \" Periodic demo \" ;obs " , 5 * CLOCK_SECOND ) ;
2012-02-01 02:24:49 +00:00
void
pushing_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 ) ;
/* Usually, a CoAP server would response with the resource representation matching the periodic_handler. */
const char * msg = " It's periodic! " ;
REST . set_response_payload ( response , msg , strlen ( msg ) ) ;
/* 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 .
*/
2012-03-23 15:29:25 +00:00
void
2012-02-01 02:24:49 +00:00
pushing_periodic_handler ( resource_t * r )
{
2012-03-23 15:29:25 +00:00
static uint16_t obs_counter = 0 ;
static char content [ 11 ] ;
2012-02-01 02:24:49 +00:00
2012-03-23 15:29:25 +00:00
+ + obs_counter ;
2012-02-01 02:24:49 +00:00
2012-03-23 15:29:25 +00:00
PRINTF ( " TICK %u for /%s \n " , periodic_i , r - > url ) ;
2012-02-01 02:24:49 +00:00
2012-03-23 15:29:25 +00:00
/* Build notification. */
coap_packet_t notification [ 1 ] ; /* This way the packet can be treated as pointer as usual. */
coap_init_message ( notification , COAP_TYPE_NON , CONTENT_2_05 , 0 ) ;
coap_set_payload ( notification , content , snprintf ( content , sizeof ( content ) , " TICK %u " , obs_counter ) ) ;
/* Notify the registered observers with the given message type, observe option, and payload. */
REST . notify_subscribers ( r , obs_counter , notification ) ;
2012-02-01 02:24:49 +00:00
}
# endif
2012-01-12 19:19:54 +00:00
# if defined (PLATFORM_HAS_BUTTON) && REST_RES_EVENT
2011-09-14 14:33:01 +00:00
/*
* 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 .
*/
2012-03-17 15:51:28 +00:00
EVENT_RESOURCE ( event , METHOD_GET , " sensors/button " , " title= \" Event demo \" ;obs " ) ;
2011-09-14 14:33:01 +00:00
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 ) ;
2012-01-28 17:52:14 +00:00
/* Usually, a CoAP server would response with the current resource representation. */
2012-02-01 02:24:49 +00:00
const char * msg = " It's eventful! " ;
REST . set_response_payload ( response , ( uint8_t * ) msg , strlen ( msg ) ) ;
2011-09-14 14:33:01 +00:00
/* 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 . */
2012-03-23 15:29:25 +00:00
void
2011-09-14 14:33:01 +00:00
event_event_handler ( resource_t * r )
{
2012-03-23 15:29:25 +00:00
static uint16_t event_counter = 0 ;
static char content [ 12 ] ;
+ + event_counter ;
2011-09-14 14:33:01 +00:00
2012-03-23 15:29:25 +00:00
PRINTF ( " TICK %u for /%s \n " , event_counter , r - > url ) ;
2011-09-14 14:33:01 +00:00
2012-03-23 15:29:25 +00:00
/* Build notification. */
coap_packet_t notification [ 1 ] ; /* This way the packet can be treated as pointer as usual. */
coap_init_message ( notification , COAP_TYPE_CON , CONTENT_2_05 , 0 ) ;
coap_set_payload ( notification , content , snprintf ( content , sizeof ( content ) , " EVENT %u " , event_counter ) ) ;
2011-09-14 14:33:01 +00:00
2012-03-23 15:29:25 +00:00
/* Notify the registered observers with the given message type, observe option, and payload. */
REST . notify_subscribers ( r , event_counter , notification ) ;
2011-09-14 14:33:01 +00:00
}
# endif /* PLATFORM_HAS_BUTTON */
# if defined (PLATFORM_HAS_LEDS)
2012-01-12 19:19:54 +00:00
# if REST_RES_LEDS
2011-09-14 14:33:01 +00:00
/*A simple actuator example, depending on the color query parameter and post variable mode, corresponding led is activated or deactivated*/
2012-01-12 19:19:54 +00:00
RESOURCE ( leds , METHOD_POST | METHOD_PUT , " actuators/leds " , " title= \" LEDs: ?color=r|g|b, POST/PUT mode=on|off \" ;rt= \" Control \" " ) ;
2011-09-14 14:33:01 +00:00
void
2012-01-12 19:19:54 +00:00
leds_handler ( void * request , void * response , uint8_t * buffer , uint16_t preferred_size , int32_t * offset )
2011-09-14 14:33:01 +00:00
{
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 ) ;
2011-10-10 12:16:27 +00:00
if ( strncmp ( color , " r " , len ) = = 0 ) {
2011-09-14 14:33:01 +00:00
led = LEDS_RED ;
2011-10-10 12:16:27 +00:00
} else if ( strncmp ( color , " g " , len ) = = 0 ) {
2011-09-14 14:33:01 +00:00
led = LEDS_GREEN ;
2011-10-10 12:16:27 +00:00
} else if ( strncmp ( color , " b " , len ) = = 0 ) {
2011-09-14 14:33:01 +00:00
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 ) ;
}
}
2012-01-12 19:19:54 +00:00
# endif
2011-09-14 14:33:01 +00:00
2012-01-12 19:19:54 +00:00
# if REST_RES_TOGGLE
2011-09-14 14:33:01 +00:00
/* A simple actuator example. Toggles the red led */
2011-12-07 19:51:03 +00:00
RESOURCE ( toggle , METHOD_GET | METHOD_PUT | METHOD_POST , " actuators/toggle " , " title= \" Red LED \" ;rt= \" Control \" " ) ;
2011-09-14 14:33:01 +00:00
void
toggle_handler ( void * request , void * response , uint8_t * buffer , uint16_t preferred_size , int32_t * offset )
{
leds_toggle ( LEDS_RED ) ;
}
2012-01-12 19:19:54 +00:00
# endif
2011-09-14 14:33:01 +00:00
# endif /* PLATFORM_HAS_LEDS */
2012-01-12 19:19:54 +00:00
# if defined (PLATFORM_HAS_LIGHT) && REST_RES_LIGHT
2011-09-14 14:33:01 +00:00
/* A simple getter example. Returns the reading from light sensor with a simple etag */
2011-12-07 19:51:03 +00:00
RESOURCE ( light , METHOD_GET , " sensors/light " , " title= \" Photosynthetic and solar light (supports JSON) \" ;rt= \" LightSensor \" " ) ;
2011-09-14 14:33:01 +00:00
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 ) ;
2012-01-20 17:30:12 +00:00
const uint16_t * accept = NULL ;
2011-09-14 14:33:01 +00:00
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= \" %u \" solar= \" %u \" /> " , 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 ) ;
2012-02-01 02:24:49 +00:00
const char * msg = " Supporting content-types text/plain, application/xml, and application/json " ;
REST . set_response_payload ( response , msg , strlen ( msg ) ) ;
2011-09-14 14:33:01 +00:00
}
}
# endif /* PLATFORM_HAS_LIGHT */
2012-01-12 19:19:54 +00:00
# if defined (PLATFORM_HAS_BATTERY) && REST_RES_BATTERY
2011-09-14 14:33:01 +00:00
/* A simple getter example. Returns the reading from light sensor with a simple etag */
2011-12-07 19:51:03 +00:00
RESOURCE ( battery , METHOD_GET , " sensors/battery " , " title= \" Battery status \" ;rt= \" Battery \" " ) ;
2011-09-14 14:33:01 +00:00
void
battery_handler ( void * request , void * response , uint8_t * buffer , uint16_t preferred_size , int32_t * offset )
{
int battery = battery_sensor . value ( 0 ) ;
2012-01-20 17:30:12 +00:00
const uint16_t * accept = NULL ;
2011-09-14 14:33:01 +00:00
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 ) ;
2012-02-01 02:24:49 +00:00
const char * msg = " Supporting content-types text/plain and application/json " ;
REST . set_response_payload ( response , msg , strlen ( msg ) ) ;
2011-09-14 14:33:01 +00:00
}
}
# 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
2012-01-31 03:38:07 +00:00
/* Initialize the REST engine. */
rest_init_engine ( ) ;
2011-09-14 14:33:01 +00:00
/* Activate the application-specific resources. */
2012-01-12 19:19:54 +00:00
# if REST_RES_HELLO
2011-09-14 14:33:01 +00:00
rest_activate_resource ( & resource_helloworld ) ;
2012-01-12 19:19:54 +00:00
# endif
# if REST_RES_MIRROR
2011-09-14 14:33:01 +00:00
rest_activate_resource ( & resource_mirror ) ;
2012-01-12 19:19:54 +00:00
# endif
# if REST_RES_CHUNKS
2011-09-14 14:33:01 +00:00
rest_activate_resource ( & resource_chunks ) ;
2012-01-12 19:19:54 +00:00
# endif
2012-02-01 02:24:49 +00:00
# if REST_RES_PUSHING
rest_activate_periodic_resource ( & periodic_resource_pushing ) ;
2012-01-12 19:19:54 +00:00
# endif
2012-02-06 05:21:33 +00:00
# if defined (PLATFORM_HAS_BUTTON) && REST_RES_EVENT
rest_activate_event_resource ( & resource_event ) ;
# endif
# if defined (PLATFORM_HAS_BUTTON) && REST_RES_SEPARATE && WITH_COAP > 3
2012-03-29 16:05:07 +00:00
/* No pre-handler anymore, user coap_separate_accept() and coap_separate_reject(). */
2012-01-31 03:38:07 +00:00
rest_activate_resource ( & resource_separate ) ;
# endif
2012-02-06 05:21:33 +00:00
# if defined (PLATFORM_HAS_BUTTON) && (REST_RES_EVENT || (REST_RES_SEPARATE && WITH_COAP > 3))
2011-09-14 14:33:01 +00:00
SENSORS_ACTIVATE ( button_sensor ) ;
# endif
# if defined (PLATFORM_HAS_LEDS)
2012-01-12 19:19:54 +00:00
# if REST_RES_LEDS
rest_activate_resource ( & resource_leds ) ;
# endif
# if REST_RES_TOGGLE
2011-09-14 14:33:01 +00:00
rest_activate_resource ( & resource_toggle ) ;
2012-01-12 19:19:54 +00:00
# endif
2011-09-14 14:33:01 +00:00
# endif /* PLATFORM_HAS_LEDS */
2012-01-12 19:19:54 +00:00
# if defined (PLATFORM_HAS_LIGHT) && REST_RES_LIGHT
2011-09-14 14:33:01 +00:00
SENSORS_ACTIVATE ( light_sensor ) ;
rest_activate_resource ( & resource_light ) ;
# endif
2012-01-12 19:19:54 +00:00
# if defined (PLATFORM_HAS_BATTERY) && REST_RES_BATTERY
2011-09-14 14:33:01 +00:00
SENSORS_ACTIVATE ( battery_sensor ) ;
rest_activate_resource ( & resource_battery ) ;
# endif
/* Define application-specific events here. */
while ( 1 ) {
PROCESS_WAIT_EVENT ( ) ;
2012-01-31 03:38:07 +00:00
# if defined (PLATFORM_HAS_BUTTON)
2011-09-14 14:33:01 +00:00
if ( ev = = sensors_event & & data = = & button_sensor ) {
PRINTF ( " BUTTON \n " ) ;
2012-01-31 03:38:07 +00:00
# if REST_RES_EVENT
2011-09-14 14:33:01 +00:00
/* Call the event_handler for this application-specific event. */
event_event_handler ( & resource_event ) ;
2012-01-31 03:38:07 +00:00
# endif
# if REST_RES_SEPARATE && WITH_COAP>3
/* Also call the separate response example handler. */
separate_finalize_handler ( ) ;
# endif
2011-09-14 14:33:01 +00:00
}
# endif /* PLATFORM_HAS_BUTTON */
} /* while (1) */
PROCESS_END ( ) ;
}