/*---------------------------------------------------------------------------*/
PROCESS_THREAD(delete_process, ev, data)
{
static struct etimer update_check_timer;
static struct etimer update_send_timer;
static struct akes_nbr_entry *next;
PROCESS_BEGIN();
PRINTF("akes-delete: Started update_process\n");
etimer_set(&update_check_timer, UPDATE_CHECK_INTERVAL * CLOCK_SECOND);
while(1) {
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&update_check_timer));
PRINTF("akes-delete: #permanent = %d\n", akes_nbr_count(AKES_NBR_PERMANENT));
next = akes_nbr_head();
while(next) {
if(!next->permanent || !akes_nbr_is_expired(next, AKES_NBR_PERMANENT)) {
next = akes_nbr_next(next);
continue;
}
/* wait for a random period of time to avoid collisions */
etimer_set(&update_send_timer, akes_get_random_waiting_period());
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&update_send_timer));
/* check if something happened in the meantime */
if(!akes_nbr_is_expired(next, AKES_NBR_PERMANENT)) {
next = akes_nbr_next(next);
continue;
}
/* send UPDATE */
akes_send_update(next);
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
PRINTF("akes-delete: Sent UPDATE\n");
etimer_set(&update_send_timer, UPDATEACK_WAITING_PERIOD * CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&update_send_timer));
if(akes_nbr_is_expired(next, AKES_NBR_PERMANENT)) {
akes_nbr_delete(next, AKES_NBR_PERMANENT);
next = akes_nbr_head();
} else {
next = akes_nbr_next(next);
}
}
etimer_restart(&update_check_timer);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static enum cmd_broker_result
on_helloack(uint8_t *payload, int p_flag)
{
struct akes_nbr_entry *entry;
uint8_t *secret;
uint8_t key[AKES_NBR_CHALLENGE_LEN * 2];
int is_new;
PRINTF("akes: Received HELLOACK\n");
if(!akes_is_acceptable_helloack()) {
return CMD_BROKER_ERROR;
}
akes_nbr_delete_expired_tentatives();
entry = akes_nbr_get_sender_entry();
if(entry && entry->permanent && p_flag) {
PRINTF("akes: No need to start a new session\n");
return CMD_BROKER_ERROR;
}
secret = AKES_SCHEME.get_secret_with_helloack_sender(packetbuf_addr(PACKETBUF_ADDR_SENDER));
if(!secret) {
PRINTF("akes: No secret with HELLOACK sender\n");
return CMD_BROKER_ERROR;
}
/* copy challenges and generate key */
akes_nbr_copy_challenge(key, hello_challenge);
akes_nbr_copy_challenge(key + AKES_NBR_CHALLENGE_LEN, payload);
generate_pairwise_key(key, secret);
#if ANTI_REPLAY_WITH_SUPPRESSION
packetbuf_set_attr(PACKETBUF_ATTR_NEIGHBOR_INDEX, payload[AKES_NBR_CHALLENGE_LEN]);
anti_replay_parse_counter(payload + AKES_NBR_CHALLENGE_LEN + 1);
#endif /* ANTI_REPLAY_WITH_SUPPRESSION */
if(adaptivesec_verify(key)) {
PRINTF("akes: Invalid HELLOACK\n");
return CMD_BROKER_ERROR;
}
is_new = 1;
if(entry) {
if(entry->permanent) {
if(
#if AKES_NBR_WITH_PAIRWISE_KEYS
!memcmp(key, entry->permanent->pairwise_key, AES_128_KEY_LENGTH)) {
#else /* AKES_NBR_WITH_PAIRWISE_KEYS */
!memcmp(payload, entry->permanent->helloack_challenge, AKES_NBR_CACHED_HELLOACK_CHALLENGE_LEN)) {
#endif /* AKES_NBR_WITH_PAIRWISE_KEYS */
PRINTF("akes: Replayed HELLOACK\n");
return CMD_BROKER_ERROR;
} else {
akes_nbr_delete(entry, AKES_NBR_PERMANENT);
is_new = 0;
}
}
if(entry->tentative) {
#if !AKES_NBR_WITH_PAIRWISE_KEYS
if(!entry->tentative->meta->has_wait_timer) {
PRINTF("akes: Awaiting acknowledgement of ACK\n");
return CMD_BROKER_ERROR;
}
#endif /* !AKES_NBR_WITH_PAIRWISE_KEYS */
if(ctimer_expired(&entry->tentative->meta->wait_timer)) {
PRINTF("akes: Awaiting ACK\n");
return CMD_BROKER_ERROR;
} else {
PRINTF("akes: Skipping HELLOACK\n");
ctimer_stop(&entry->tentative->meta->wait_timer);
akes_nbr_delete(entry, AKES_NBR_TENTATIVE);
}
}
}
