path: root/samples/net/coap_observe_client/src/coap-observe-client.c

/* 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"

#ifdef CONFIG_NANOKERNEL
#define STACKSIZE 2000
char fiberStack[STACKSIZE];
#endif

static coap_observee_t *obs;

/* The peer is the server in our case. Just invent a mac
 * address for it because lower parts of the stack cannot set it
 * in this test as we do not have any radios.
 */
static uint8_t peer_mac[] = { 0x15, 0x0a, 0xbe, 0xef, 0xf0, 0x0d };

/* This is my mac address
 */
static uint8_t my_mac[] = { 0x0a, 0xbe, 0xef, 0x15, 0xf0, 0x0d };

#ifdef CONFIG_NETWORKING_WITH_IPV6
#if 0
/* The 2001:db8::/32 is the private address space for documentation RFC 3849 */
#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 } } }
#else
#define MY_IPADDR { { { 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0x17, 0x0a, 0xbe, 0xef, 0xf0, 0x0d, 0 } } }
#define PEER_IPADDR { { { 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0x08, 0xbe, 0xef, 0x15, 0xf0, 0x0d, 0 } } }
#endif
#else /* ipv6 */
/* The 192.0.2.0/24 is the private address space for documentation RFC 5737 */
#define MY_IPADDR { { { 192, 0, 2, 2 } } }
#define PEER_IPADDR { { { 192, 0, 2, 1 } } }
#endif

#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

#ifdef 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_server()
{
	PRINT("%s: run coap observe client\n", __func__);

	net_set_mac(my_mac, sizeof(my_mac));

#ifdef CONFIG_NETWORKING_WITH_IPV4
	{
		uip_ipaddr_t addr;
		uip_ipaddr(&addr, 192,0,2,2);
		uip_sethostaddr(&addr);
	}
#else
	{
		uip_ipaddr_t *addr;
		const uip_lladdr_t *lladdr = (const uip_lladdr_t *)&peer_mac;

		addr = (uip_ipaddr_t *)&in6addr_peer;
		uip_ds6_defrt_add(addr, 0);

		/* We cannot send to peer unless it is in neighbor
		 * cache. Neighbor cache should be populated automatically
		 * but do it here so that test works from first packet.
		 */
		uip_ds6_nbr_add(addr, lladdr, 0, NBR_REACHABLE);

		addr = (uip_ipaddr_t *)&in6addr_my;
		uip_ds6_addr_add(addr, 0, ADDR_MANUAL);
	}
#endif
}

#ifdef 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 */

#ifdef 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)
{
  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_server();

	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)) {
#ifdef 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);
}

#ifdef CONFIG_NANOKERNEL

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

#endif /* CONFIG_NANOKERNEL */