samples/net/coap_observe_client/src/coap-observe-client.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /* coap-observe-client.c - Observe a remote resource */

 /*
  * Copyright (c) 2015 Intel Corporation.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #if defined(CONFIG_STDOUT_CONSOLE)
 #include <stdio.h>
 #define PRINT           printf
 #else
 #include <misc/printk.h>
 #define PRINT           printk
 #endif

 #if defined(CONFIG_TINYDTLS_DEBUG)
 #define DEBUG DEBUG_FULL
 #else
 #define DEBUG DEBUG_PRINT
 #endif
 #include "contiki/ip/uip-debug.h"

 #include <zephyr.h>

 #include <drivers/rand32.h>

 #include <errno.h>

 #include <net/net_core.h>
 #include <net/net_socket.h>

 #include "er-coap-engine.h"
 #include "er-coap-observe-client.h"

 #include <bluetooth/bluetooth.h>
 #include <gatt/ipss.h>

 #if defined(CONFIG_NET_TESTING)
 #include <net_testing.h>
 #endif

 #if defined(CONFIG_NANOKERNEL)
 #define STACKSIZE 2000
 char fiberStack[STACKSIZE];
 #endif

 static coap_observee_t *obs;

 #if defined(CONFIG_NETWORKING_WITH_IPV6)
 /* admin-local, dynamically allocated multicast address */
 #define MCAST_IPADDR { { { 0xff, 0x84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2 } } }

 /* Define the peer IP address where to send messages */
 #if !defined(CONFIG_NET_TESTING)
 #define PEER_IPADDR { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1 } } }
 #define MY_IPADDR { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2 } } }

 #endif

 #else /* CONFIG_NETWORKING_WITH_IPV6 */

 #error "IPv4 not supported at the moment, fix me!"

 /* Organization-local 239.192.0.0/14 */
 #define MCAST_IPADDR { { { 239, 192, 0, 2 } } }

 #if !defined(CONFIG_NET_TESTING)
 #define PEER_IPADDR { { { 192, 0, 2, 1 } } }
 #endif

 #endif /* CONFIG_NETWORKING_WITH_IPV6 */

 #define MY_PORT 8484
 #define PEER_PORT COAP_DEFAULT_PORT

 /* The path of the resource to observe */
 //#define OBS_RESOURCE_URI "test/push"
 #define OBS_RESOURCE_URI "time"

 /* Toggle interval in seconds */
 #define TOGGLE_INTERVAL 5

 #if defined(CONFIG_NETWORKING_WITH_IPV6)
 static const struct in6_addr in6addr_peer = PEER_IPADDR;
 static struct in6_addr in6addr_my = MY_IPADDR;
 #else
 static struct in_addr in4addr_peer = PEER_IPADDR;
 static struct in_addr in4addr_my = MY_IPADDR;
 #endif

 static inline void init_app(void)
 {
 	PRINT("%s: run coap observe client\n", __func__);

 #if defined(CONFIG_NET_TESTING)
 	net_testing_setup();
 #endif
 }

 #if defined(DTLS_PSK)
 /* This function is the "key store" for tinyDTLS. It is called to
  * retrieve a key for the given identity within this particular
  * session. */
 static int get_psk_info(struct dtls_context_t *ctx,
 			const session_t *session,
 			dtls_credentials_type_t type,
 			const unsigned char *id, size_t id_len,
 			unsigned char *result, size_t result_length)
 {
 	struct keymap_t {
 		unsigned char *id;
 		size_t id_length;
 		unsigned char *key;
 		size_t key_length;
 	} psk[3] = {
 		{ (unsigned char *)"Client_identity", 15,
 		  (unsigned char *)"secretPSK", 9 },
 		{ (unsigned char *)"default identity", 16,
 		  (unsigned char *)"\x11\x22\x33", 3 },
 		{ (unsigned char *)"\0", 2,
 		  (unsigned char *)"", 1 }
 	};

 	if (type != DTLS_PSK_KEY) {
 		return 0;
 	}

 	if (id) {
 		int i;
 		for (i = 0; i < sizeof(psk)/sizeof(struct keymap_t); i++) {
 			if (id_len == psk[i].id_length &&
 			    memcmp(id, psk[i].id, id_len) == 0) {
 				if (result_length < psk[i].key_length) {
 					PRINTF("buffer too small for PSK");
 					return dtls_alert_fatal_create(DTLS_ALERT_INTERNAL_ERROR);
 				}

 				memcpy(result, psk[i].key, psk[i].key_length);
 				return psk[i].key_length;
 			}
 		}
 	}

 	return dtls_alert_fatal_create(DTLS_ALERT_DECRYPT_ERROR);
 }
 #else
 #define get_psk_info NULL
 #endif /* DTLS_PSK */

 #if defined(DTLS_ECC)
 const unsigned char ecdsa_priv_key[] = {
 			0xD9, 0xE2, 0x70, 0x7A, 0x72, 0xDA, 0x6A, 0x05,
 			0x04, 0x99, 0x5C, 0x86, 0xED, 0xDB, 0xE3, 0xEF,
 			0xC7, 0xF1, 0xCD, 0x74, 0x83, 0x8F, 0x75, 0x70,
 			0xC8, 0x07, 0x2D, 0x0A, 0x76, 0x26, 0x1B, 0xD4};

 const unsigned char ecdsa_pub_key_x[] = {
 			0xD0, 0x55, 0xEE, 0x14, 0x08, 0x4D, 0x6E, 0x06,
 			0x15, 0x59, 0x9D, 0xB5, 0x83, 0x91, 0x3E, 0x4A,
 			0x3E, 0x45, 0x26, 0xA2, 0x70, 0x4D, 0x61, 0xF2,
 			0x7A, 0x4C, 0xCF, 0xBA, 0x97, 0x58, 0xEF, 0x9A};

 const unsigned char ecdsa_pub_key_y[] = {
 			0xB4, 0x18, 0xB6, 0x4A, 0xFE, 0x80, 0x30, 0xDA,
 			0x1D, 0xDC, 0xF4, 0xF4, 0x2E, 0x2F, 0x26, 0x31,
 			0xD0, 0x43, 0xB1, 0xFB, 0x03, 0xE2, 0x2F, 0x4D,
 			0x17, 0xDE, 0x43, 0xF9, 0xF9, 0xAD, 0xEE, 0x70};

 static int get_ecdsa_key(struct dtls_context_t *ctx,
 			 const session_t *session,
 			 const dtls_ecdsa_key_t **result)
 {
 	static const dtls_ecdsa_key_t ecdsa_key = {
 		.curve = DTLS_ECDH_CURVE_SECP256R1,
 		.priv_key = ecdsa_priv_key,
 		.pub_key_x = ecdsa_pub_key_x,
 		.pub_key_y = ecdsa_pub_key_y
 	};

 	*result = &ecdsa_key;
 	return 0;
 }

 static int verify_ecdsa_key(struct dtls_context_t *ctx,
 			    const session_t *session,
 			    const unsigned char *other_pub_x,
 			    const unsigned char *other_pub_y,
 			    size_t key_size)
 {
 	return 0;
 }
 #else
 #define get_ecdsa_key    NULL
 #define verify_ecdsa_key NULL
 #endif /* DTLS_ECC */

 /*
  * Handle the response to the observe request and the following notifications
  */
 static void notification_callback(coap_observee_t *obs, void *notification,
 				  coap_notification_flag_t flag)
 {
 	int len = 0;
 	const uint8_t *payload = NULL;

 	PRINT("Notification handler\n");
 	PRINT("Observee URI: %s\n", obs->url);
 	if(notification) {
 		len = coap_get_payload(notification, &payload);
 	}
 	switch(flag) {
 	case NOTIFICATION_OK:
 		PRINT("NOTIFICATION OK: %*s\n", len, (char *)payload);
 		break;
 	case OBSERVE_OK: /* server accepeted observation request */
 		PRINT("OBSERVE_OK: %*s\n", len, (char *)payload);
 		break;
 	case OBSERVE_NOT_SUPPORTED:
 		PRINT("OBSERVE_NOT_SUPPORTED: %*s\n", len, (char *)payload);
 		obs = NULL;
 		break;
 	case ERROR_RESPONSE_CODE:
 		PRINT("ERROR_RESPONSE_CODE: %*s\n", len, (char *)payload);
 		obs = NULL;
 		break;
 	case NO_REPLY_FROM_SERVER:
 		PRINT("NO_REPLY_FROM_SERVER: "
 		      "removing observe registration with token %x%x\n",
 		      obs->token[0], obs->token[1]);
 		obs = NULL;
 		break;
 	}
 }

 /*
  * Toggle the observation of the remote resource
  */
 void toggle_observation(coap_context_t *coap_ctx)
 {
 	if(obs) {
 		PRINT("Stopping observation\n");
 		coap_obs_remove_observee(obs);
 		obs = NULL;
 	} else {
 		PRINT("Starting observation\n");
 		obs = coap_obs_request_registration(coap_ctx,
 					    (uip_ipaddr_t *)&in6addr_peer,
 						    PEER_PORT,
 						    OBS_RESOURCE_URI,
 						    notification_callback,
 						    NULL);
 	}
 }

 #define WAIT_TIME 1
 #define WAIT_TICKS (WAIT_TIME * sys_clock_ticks_per_sec)

 #if 0
 #define WAIT_PEER (5 * sys_clock_ticks_per_sec)
 #else
 #define WAIT_PEER TICKS_UNLIMITED
 #endif

 PROCESS(coap_observe_client_process, "CoAP observe client process");
 PROCESS_THREAD(coap_observe_client_process, ev, data, buf, user_data)
 {
   PROCESS_BEGIN();

   while(1) {
     PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_TIMER);
     /* Currently the timeout is handled in while loop in startup() */
   }
   PROCESS_END();
 }

 void startup(void)
 {
 	static struct etimer et;
 	static coap_context_t *coap_ctx;
 	bool first_round = true;

 	net_init();

 	coap_init_engine();
 	coap_init_mid();

 	init_app();

 #if defined(CONFIG_NETWORKING_WITH_BT)
 	if (bt_enable(NULL)) {
 		PRINT("Bluetooth init failed\n");
 		return;
 	}
 	ipss_init();
 	ipss_advertise();
 #endif

 	coap_ctx = coap_context_new((uip_ipaddr_t *)&in6addr_my, MY_PORT);
 	if (!coap_ctx) {
 		PRINT("Cannot get CoAP context.\n");
 		return;
 	}

 	coap_context_set_key_handlers(coap_ctx,
 				      get_psk_info,
 				      get_ecdsa_key,
 				      verify_ecdsa_key);

 	if (!coap_context_connect(coap_ctx,
 				  (uip_ipaddr_t *)&in6addr_peer,
 				  PEER_PORT)) {
 		PRINT("Cannot connect to peer.\n");
 		return;
 	}

 	etimer_set(&et, TOGGLE_INTERVAL * sys_clock_ticks_per_sec,
 		   &coap_observe_client_process);

 	while (1) {
 		while (!coap_context_is_connected(coap_ctx)) {
 			PRINT("Trying to connect to peer...\n");
 			if (!coap_context_wait_data(coap_ctx, WAIT_TICKS)) {
 				continue;
 			}
 		}

 		if(first_round || etimer_expired(&et)) {
 			PRINT("--Toggle timer--\n");
 			toggle_observation(coap_ctx);
 			PRINT("--Done--\n");
 			etimer_restart(&et);
 			first_round = false;
 		}

 		if (coap_context_wait_data(coap_ctx, WAIT_TICKS)) {
 #if defined(CONFIG_NANOKERNEL)
 			/* Print the stack usage only if we did something */
 			net_analyze_stack("CoAP observe client",
 					  fiberStack, STACKSIZE);
 #endif
 		}

 		coap_check_transactions();
 	}
 	coap_context_close(coap_ctx);
 }

 #if defined(CONFIG_NANOKERNEL)

 void main(void)
 {
 	fiber_start(&fiberStack[0], STACKSIZE,
 			(nano_fiber_entry_t)startup, 0, 0, 7, 0);
 }

 #endif /* CONFIG_NANOKERNEL */
	/* coap-observe-client.c - Observe a remote resource */

	/*
	* Copyright (c) 2015 Intel Corporation.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#if defined(CONFIG_STDOUT_CONSOLE)
	#include <stdio.h>
	#define PRINT printf
	#else
	#include <misc/printk.h>
	#define PRINT printk
	#endif

	#if defined(CONFIG_TINYDTLS_DEBUG)
	#define DEBUG DEBUG_FULL
	#else
	#define DEBUG DEBUG_PRINT
	#endif
	#include "contiki/ip/uip-debug.h"

	#include <zephyr.h>

	#include <drivers/rand32.h>

	#include <errno.h>

	#include <net/net_core.h>
	#include <net/net_socket.h>

	#include "er-coap-engine.h"
	#include "er-coap-observe-client.h"

	#include <bluetooth/bluetooth.h>
	#include <gatt/ipss.h>

	#if defined(CONFIG_NET_TESTING)
	#include <net_testing.h>
	#endif

	#if defined(CONFIG_NANOKERNEL)
	#define STACKSIZE 2000
	char fiberStack[STACKSIZE];
	#endif

	static coap_observee_t *obs;

	#if defined(CONFIG_NETWORKING_WITH_IPV6)
	/* admin-local, dynamically allocated multicast address */
	#define MCAST_IPADDR { { { 0xff, 0x84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2 } } }

	/* Define the peer IP address where to send messages */
	#if !defined(CONFIG_NET_TESTING)
	#define PEER_IPADDR { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1 } } }
	#define MY_IPADDR { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2 } } }

	#endif

	#else /* CONFIG_NETWORKING_WITH_IPV6 */

	#error "IPv4 not supported at the moment, fix me!"

	/* Organization-local 239.192.0.0/14 */
	#define MCAST_IPADDR { { { 239, 192, 0, 2 } } }

	#if !defined(CONFIG_NET_TESTING)
	#define PEER_IPADDR { { { 192, 0, 2, 1 } } }
	#endif

	#endif /* CONFIG_NETWORKING_WITH_IPV6 */

	#define MY_PORT 8484
	#define PEER_PORT COAP_DEFAULT_PORT

	/* The path of the resource to observe */
	//#define OBS_RESOURCE_URI "test/push"
	#define OBS_RESOURCE_URI "time"

	/* Toggle interval in seconds */
	#define TOGGLE_INTERVAL 5

	#if defined(CONFIG_NETWORKING_WITH_IPV6)
	static const struct in6_addr in6addr_peer = PEER_IPADDR;
	static struct in6_addr in6addr_my = MY_IPADDR;
	#else
	static struct in_addr in4addr_peer = PEER_IPADDR;
	static struct in_addr in4addr_my = MY_IPADDR;
	#endif

	static inline void init_app(void)
	{
	PRINT("%s: run coap observe client\n", __func__);

	#if defined(CONFIG_NET_TESTING)
	net_testing_setup();
	#endif
	}

	#if defined(DTLS_PSK)
	/* This function is the "key store" for tinyDTLS. It is called to
	* retrieve a key for the given identity within this particular
	* session. */
	static int get_psk_info(struct dtls_context_t *ctx,
	const session_t *session,
	dtls_credentials_type_t type,
	const unsigned char *id, size_t id_len,
	unsigned char *result, size_t result_length)
	{
	struct keymap_t {
	unsigned char *id;
	size_t id_length;
	unsigned char *key;
	size_t key_length;
	} psk[3] = {
	{ (unsigned char *)"Client_identity", 15,
	(unsigned char *)"secretPSK", 9 },
	{ (unsigned char *)"default identity", 16,
	(unsigned char *)"\x11\x22\x33", 3 },
	{ (unsigned char *)"\0", 2,
	(unsigned char *)"", 1 }
	};

	if (type != DTLS_PSK_KEY) {
	return 0;
	}

	if (id) {
	int i;
	for (i = 0; i < sizeof(psk)/sizeof(struct keymap_t); i++) {
	if (id_len == psk[i].id_length &&
	memcmp(id, psk[i].id, id_len) == 0) {
	if (result_length < psk[i].key_length) {
	PRINTF("buffer too small for PSK");
	return dtls_alert_fatal_create(DTLS_ALERT_INTERNAL_ERROR);
	}

	memcpy(result, psk[i].key, psk[i].key_length);
	return psk[i].key_length;
	}
	}
	}

	return dtls_alert_fatal_create(DTLS_ALERT_DECRYPT_ERROR);
	}
	#else
	#define get_psk_info NULL
	#endif /* DTLS_PSK */

	#if defined(DTLS_ECC)
	const unsigned char ecdsa_priv_key[] = {
	0xD9, 0xE2, 0x70, 0x7A, 0x72, 0xDA, 0x6A, 0x05,
	0x04, 0x99, 0x5C, 0x86, 0xED, 0xDB, 0xE3, 0xEF,
	0xC7, 0xF1, 0xCD, 0x74, 0x83, 0x8F, 0x75, 0x70,
	0xC8, 0x07, 0x2D, 0x0A, 0x76, 0x26, 0x1B, 0xD4};

	const unsigned char ecdsa_pub_key_x[] = {
	0xD0, 0x55, 0xEE, 0x14, 0x08, 0x4D, 0x6E, 0x06,
	0x15, 0x59, 0x9D, 0xB5, 0x83, 0x91, 0x3E, 0x4A,
	0x3E, 0x45, 0x26, 0xA2, 0x70, 0x4D, 0x61, 0xF2,
	0x7A, 0x4C, 0xCF, 0xBA, 0x97, 0x58, 0xEF, 0x9A};

	const unsigned char ecdsa_pub_key_y[] = {
	0xB4, 0x18, 0xB6, 0x4A, 0xFE, 0x80, 0x30, 0xDA,
	0x1D, 0xDC, 0xF4, 0xF4, 0x2E, 0x2F, 0x26, 0x31,
	0xD0, 0x43, 0xB1, 0xFB, 0x03, 0xE2, 0x2F, 0x4D,
	0x17, 0xDE, 0x43, 0xF9, 0xF9, 0xAD, 0xEE, 0x70};

	static int get_ecdsa_key(struct dtls_context_t *ctx,
	const session_t *session,
	const dtls_ecdsa_key_t **result)
	{
	static const dtls_ecdsa_key_t ecdsa_key = {
	.curve = DTLS_ECDH_CURVE_SECP256R1,
	.priv_key = ecdsa_priv_key,
	.pub_key_x = ecdsa_pub_key_x,
	.pub_key_y = ecdsa_pub_key_y
	};

	*result = &ecdsa_key;
	return 0;
	}

	static int verify_ecdsa_key(struct dtls_context_t *ctx,
	const session_t *session,
	const unsigned char *other_pub_x,
	const unsigned char *other_pub_y,
	size_t key_size)
	{
	return 0;
	}
	#else
	#define get_ecdsa_key NULL
	#define verify_ecdsa_key NULL
	#endif /* DTLS_ECC */

	/*
	* Handle the response to the observe request and the following notifications
	*/
	static void notification_callback(coap_observee_t obs, void notification,
	coap_notification_flag_t flag)
	{
	int len = 0;
	const uint8_t *payload = NULL;

	PRINT("Notification handler\n");
	PRINT("Observee URI: %s\n", obs->url);
	if(notification) {
	len = coap_get_payload(notification, &payload);
	}
	switch(flag) {
	case NOTIFICATION_OK:
	PRINT("NOTIFICATION OK: %s\n", len, (char )payload);
	break;
	case OBSERVE_OK: /* server accepeted observation request */
	PRINT("OBSERVE_OK: %s\n", len, (char )payload);
	break;
	case OBSERVE_NOT_SUPPORTED:
	PRINT("OBSERVE_NOT_SUPPORTED: %s\n", len, (char )payload);
	obs = NULL;
	break;
	case ERROR_RESPONSE_CODE:
	PRINT("ERROR_RESPONSE_CODE: %s\n", len, (char )payload);
	obs = NULL;
	break;
	case NO_REPLY_FROM_SERVER:
	PRINT("NO_REPLY_FROM_SERVER: "
	"removing observe registration with token %x%x\n",
	obs->token[0], obs->token[1]);
	obs = NULL;
	break;
	}
	}

	/*
	* Toggle the observation of the remote resource
	*/
	void toggle_observation(coap_context_t *coap_ctx)
	{
	if(obs) {
	PRINT("Stopping observation\n");
	coap_obs_remove_observee(obs);
	obs = NULL;
	} else {
	PRINT("Starting observation\n");
	obs = coap_obs_request_registration(coap_ctx,
	(uip_ipaddr_t *)&in6addr_peer,
	PEER_PORT,
	OBS_RESOURCE_URI,
	notification_callback,
	NULL);
	}
	}

	#define WAIT_TIME 1
	#define WAIT_TICKS (WAIT_TIME * sys_clock_ticks_per_sec)

	#if 0
	#define WAIT_PEER (5 * sys_clock_ticks_per_sec)
	#else
	#define WAIT_PEER TICKS_UNLIMITED
	#endif

	PROCESS(coap_observe_client_process, "CoAP observe client process");
	PROCESS_THREAD(coap_observe_client_process, ev, data, buf, user_data)
	{
	PROCESS_BEGIN();

	while(1) {
	PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_TIMER);
	/* Currently the timeout is handled in while loop in startup() */
	}
	PROCESS_END();
	}

	void startup(void)
	{
	static struct etimer et;
	static coap_context_t *coap_ctx;
	bool first_round = true;

	net_init();

	coap_init_engine();
	coap_init_mid();

	init_app();

	#if defined(CONFIG_NETWORKING_WITH_BT)
	if (bt_enable(NULL)) {
	PRINT("Bluetooth init failed\n");
	return;
	}
	ipss_init();
	ipss_advertise();
	#endif

	coap_ctx = coap_context_new((uip_ipaddr_t *)&in6addr_my, MY_PORT);
	if (!coap_ctx) {
	PRINT("Cannot get CoAP context.\n");
	return;
	}

	coap_context_set_key_handlers(coap_ctx,
	get_psk_info,
	get_ecdsa_key,
	verify_ecdsa_key);

	if (!coap_context_connect(coap_ctx,
	(uip_ipaddr_t *)&in6addr_peer,
	PEER_PORT)) {
	PRINT("Cannot connect to peer.\n");
	return;
	}

	etimer_set(&et, TOGGLE_INTERVAL * sys_clock_ticks_per_sec,
	&coap_observe_client_process);

	while (1) {
	while (!coap_context_is_connected(coap_ctx)) {
	PRINT("Trying to connect to peer...\n");
	if (!coap_context_wait_data(coap_ctx, WAIT_TICKS)) {
	continue;
	}
	}

	if(first_round \|\| etimer_expired(&et)) {
	PRINT("--Toggle timer--\n");
	toggle_observation(coap_ctx);
	PRINT("--Done--\n");
	etimer_restart(&et);
	first_round = false;
	}

	if (coap_context_wait_data(coap_ctx, WAIT_TICKS)) {
	#if defined(CONFIG_NANOKERNEL)
	/* Print the stack usage only if we did something */
	net_analyze_stack("CoAP observe client",
	fiberStack, STACKSIZE);
	#endif
	}

	coap_check_transactions();
	}
	coap_context_close(coap_ctx);
	}

	#if defined(CONFIG_NANOKERNEL)

	void main(void)
	{
	fiber_start(&fiberStack[0], STACKSIZE,
	(nano_fiber_entry_t)startup, 0, 0, 7, 0);
	}

	#endif /* CONFIG_NANOKERNEL */