389 lines
12 KiB
C
389 lines
12 KiB
C
/*
|
|
* Copyright (c) 2016, Yasuyuki Tanaka
|
|
* 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 copyright holder 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 COPYRIGHT HOLDERS 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
|
|
* COPYRIGHT HOLDER 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.
|
|
*/
|
|
/**
|
|
* \addtogroup sixtop
|
|
* @{
|
|
*/
|
|
/**
|
|
* \file
|
|
* Transaction Management for 6top Protocol (6P)
|
|
* \author
|
|
* Yasuyuki Tanaka <yasuyuki.tanaka@inf.ethz.ch>
|
|
*/
|
|
|
|
#include "contiki-lib.h"
|
|
#include "lib/assert.h"
|
|
|
|
#include "sixtop.h"
|
|
#include "sixtop-conf.h"
|
|
#include "sixp-trans.h"
|
|
|
|
#define DEBUG DEBUG_PRINT
|
|
#include "net/net-debug.h"
|
|
|
|
/**
|
|
* \brief 6P Transaction Data Structure (for internal use)
|
|
*/
|
|
typedef struct sixp_trans {
|
|
struct sixp_trans *next;
|
|
const sixtop_sf_t *sf;
|
|
linkaddr_t peer_addr;
|
|
uint8_t seqno;
|
|
sixp_pkt_cmd_t cmd;
|
|
sixp_trans_state_t state;
|
|
sixp_trans_mode_t mode;
|
|
struct {
|
|
sixp_sent_callback_t func;
|
|
void *arg;
|
|
uint16_t arg_len;
|
|
} callback;
|
|
struct ctimer timer;
|
|
} sixp_trans_t;
|
|
|
|
static void handle_trans_timeout(void *ptr);
|
|
static void process_trans(void *ptr);
|
|
static void schedule_trans_process(sixp_trans_t *trans);
|
|
static void free_trans(sixp_trans_t *trans);
|
|
static sixp_trans_mode_t determine_trans_mode(const sixp_pkt_t *req);
|
|
|
|
MEMB(trans_memb, sixp_trans_t, SIXTOP_MAX_TRANSACTIONS);
|
|
LIST(trans_list);
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
handle_trans_timeout(void *ptr)
|
|
{
|
|
sixp_trans_t *trans = (sixp_trans_t *)ptr;
|
|
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
return;
|
|
}
|
|
|
|
if(trans->sf->timeout != NULL) {
|
|
trans->sf->timeout(trans->cmd,
|
|
(const linkaddr_t *)&trans->peer_addr);
|
|
}
|
|
|
|
(void)sixp_trans_transit_state(trans, SIXP_TRANS_STATE_TERMINATING);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
process_trans(void *ptr)
|
|
{
|
|
sixp_trans_t *trans = (sixp_trans_t *)ptr;
|
|
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* make sure that the timer is stopped */
|
|
ctimer_stop(&trans->timer);
|
|
|
|
/* state-specific operation */
|
|
if(trans->state == SIXP_TRANS_STATE_TERMINATING) {
|
|
/* handle the terminating state first */
|
|
PRINTF("6P-trans: trans [peer_addr:");
|
|
PRINTLLADDR((const uip_lladdr_t *)&trans->peer_addr);
|
|
PRINTF(", seqno:%u] is going to be freed\n", trans->seqno);
|
|
free_trans(trans);
|
|
return;
|
|
}
|
|
|
|
switch(trans->state) {
|
|
/* do for others */
|
|
case SIXP_TRANS_STATE_RESPONSE_SENT:
|
|
case SIXP_TRANS_STATE_RESPONSE_RECEIVED:
|
|
if(trans->mode == SIXP_TRANS_MODE_2_STEP) {
|
|
(void)sixp_trans_transit_state(trans, SIXP_TRANS_STATE_TERMINATING);
|
|
}
|
|
break;
|
|
case SIXP_TRANS_STATE_CONFIRMATION_SENT:
|
|
case SIXP_TRANS_STATE_CONFIRMATION_RECEIVED:
|
|
(void)sixp_trans_transit_state(trans, SIXP_TRANS_STATE_TERMINATING);
|
|
break;
|
|
case SIXP_TRANS_STATE_TERMINATING:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(trans->state != SIXP_TRANS_STATE_TERMINATING) {
|
|
/* set the timer with a timeout values defined by the SF */
|
|
ctimer_set(&trans->timer, trans->sf->timeout_interval,
|
|
handle_trans_timeout, trans);
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
schedule_trans_process(sixp_trans_t *trans)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
return;
|
|
}
|
|
|
|
ctimer_stop(&trans->timer);
|
|
ctimer_set(&trans->timer, 0, process_trans, trans); /* expires immediately */
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
free_trans(sixp_trans_t *trans)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
return;
|
|
}
|
|
|
|
list_remove(trans_list, trans);
|
|
memb_free(&trans_memb, trans);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static sixp_trans_mode_t
|
|
determine_trans_mode(const sixp_pkt_t *req)
|
|
{
|
|
uint16_t cell_list_len;
|
|
|
|
assert(req != NULL);
|
|
if(req == NULL) {
|
|
return SIXP_TRANS_MODE_UNAVAILABLE;
|
|
}
|
|
|
|
/*
|
|
* We consider a transaction as 3-step if and only if its request command is
|
|
* either Add or Delete AND its cell_list is empty. Otherwise, 2-step.
|
|
*/
|
|
if(req->type == SIXP_PKT_TYPE_REQUEST &&
|
|
(req->code.cmd == SIXP_PKT_CMD_ADD ||
|
|
req->code.cmd == SIXP_PKT_CMD_DELETE) &&
|
|
sixp_pkt_get_cell_list(req->type, (sixp_pkt_code_t)req->code.value,
|
|
NULL, &cell_list_len,
|
|
req->body, req->body_len) == 0 &&
|
|
cell_list_len == 0) {
|
|
return SIXP_TRANS_MODE_3_STEP;
|
|
}
|
|
|
|
return SIXP_TRANS_MODE_2_STEP;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
int
|
|
sixp_trans_transit_state(sixp_trans_t *trans, sixp_trans_state_t new_state)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
PRINTF("6top: invalid argument, trans is NULL\n");
|
|
return -1;
|
|
}
|
|
|
|
/* enforce state transition rules */
|
|
if(new_state == SIXP_TRANS_STATE_TERMINATING ||
|
|
(new_state == SIXP_TRANS_STATE_REQUEST_SENT &&
|
|
trans->state == SIXP_TRANS_STATE_INIT) ||
|
|
(new_state == SIXP_TRANS_STATE_REQUEST_RECEIVED &&
|
|
trans->state == SIXP_TRANS_STATE_INIT) ||
|
|
(new_state == SIXP_TRANS_STATE_RESPONSE_SENT &&
|
|
trans->state == SIXP_TRANS_STATE_REQUEST_RECEIVED) ||
|
|
(new_state == SIXP_TRANS_STATE_RESPONSE_RECEIVED &&
|
|
trans->state == SIXP_TRANS_STATE_REQUEST_SENT) ||
|
|
(new_state == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED &&
|
|
trans->state == SIXP_TRANS_STATE_RESPONSE_SENT &&
|
|
trans->mode == SIXP_TRANS_MODE_3_STEP) ||
|
|
(new_state == SIXP_TRANS_STATE_CONFIRMATION_SENT &&
|
|
trans->state == SIXP_TRANS_STATE_RESPONSE_RECEIVED &&
|
|
trans->mode == SIXP_TRANS_MODE_3_STEP)) {
|
|
PRINTF("6P-trans: trans %p state changes from %u to %u\n",
|
|
trans, trans->state, new_state);
|
|
trans->state = new_state;
|
|
schedule_trans_process(trans);
|
|
return 0;
|
|
}
|
|
|
|
/* invalid transition */
|
|
PRINTF("6P-trans: invalid transaction, from %u to %u, detected on trans %p\n",
|
|
trans->state, new_state, trans);
|
|
return -1;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
sixp_pkt_cmd_t
|
|
sixp_trans_get_cmd(sixp_trans_t *trans)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
return SIXP_PKT_CMD_UNAVAILABLE;
|
|
}
|
|
return trans->cmd;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
sixp_trans_state_t
|
|
sixp_trans_get_state(sixp_trans_t *trans)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
return SIXP_TRANS_STATE_UNAVAILABLE;
|
|
}
|
|
return trans->state;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
int16_t
|
|
sixp_trans_get_seqno(sixp_trans_t *trans)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
PRINTF("6P-trans: sixp_trans_get_seqno() fails because trans is NULL\n");
|
|
return -1;
|
|
}
|
|
return trans->seqno;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
sixp_trans_mode_t
|
|
sixp_trans_get_mode(sixp_trans_t *trans)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
PRINTF("6P-trans: sixp_trans_get_mode() fails because trans is NULL\n");
|
|
return SIXP_TRANS_STATE_UNAVAILABLE;
|
|
}
|
|
return trans->mode;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
sixp_trans_invoke_callback(sixp_trans_t *trans, sixp_output_status_t status)
|
|
{
|
|
assert(trans != NULL);
|
|
|
|
if(trans == NULL || trans->callback.func == NULL) {
|
|
return;
|
|
}
|
|
trans->callback.func(trans->callback.arg, trans->callback.arg_len,
|
|
&trans->peer_addr, status);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
sixp_trans_set_callback(sixp_trans_t *trans,
|
|
sixp_sent_callback_t func, void *arg, uint16_t arg_len)
|
|
{
|
|
assert(trans != NULL);
|
|
if(trans == NULL) {
|
|
return;
|
|
}
|
|
trans->callback.func = func;
|
|
trans->callback.arg = arg;
|
|
trans->callback.arg_len = arg_len;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
sixp_trans_t *
|
|
sixp_trans_alloc(const sixp_pkt_t *pkt, const linkaddr_t *peer_addr)
|
|
{
|
|
const sixtop_sf_t *sf;
|
|
sixp_trans_t *trans;
|
|
|
|
assert(pkt != NULL && peer_addr != NULL);
|
|
if(pkt == NULL || peer_addr == NULL) {
|
|
PRINTF("6P-trans: sixp_trans_alloc() fails because of invalid argument\n");
|
|
return NULL;
|
|
}
|
|
|
|
if((sf = sixtop_find_sf(pkt->sfid)) == NULL) {
|
|
PRINTF("6P-trans: sixp_trans_alloc() fails; no suitable SF [sfid:%u]\n",
|
|
pkt->sfid);
|
|
return NULL;
|
|
}
|
|
|
|
if(sixp_trans_find(peer_addr) != NULL) {
|
|
PRINTF("6P-trans: sixp_trans_alloc() fails because another trans with ");
|
|
PRINTLLADDR((const uip_lladdr_t *)peer_addr);
|
|
PRINTF("is in process\n");
|
|
return NULL;
|
|
}
|
|
|
|
if((trans = memb_alloc(&trans_memb)) == NULL) {
|
|
PRINTF("6P-trans: sixp_trans_alloc() fails because of lack of memory\n");
|
|
return NULL;
|
|
}
|
|
|
|
memset(trans, 0, sizeof(sixp_trans_t));
|
|
trans->sf = sf;
|
|
trans->peer_addr = *peer_addr;
|
|
trans->seqno = pkt->seqno;
|
|
trans->cmd = pkt->code.value;
|
|
trans->state = SIXP_TRANS_STATE_INIT;
|
|
trans->mode = determine_trans_mode(pkt);
|
|
list_add(trans_list, trans);
|
|
|
|
return trans;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
sixp_trans_t *
|
|
sixp_trans_find(const linkaddr_t *peer_addr)
|
|
{
|
|
sixp_trans_t *trans;
|
|
|
|
assert(peer_addr != NULL);
|
|
if(peer_addr == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* XXX: we don't support concurrent 6P transactions which is mentioned in
|
|
* Section 4.3.3, draft-ietf-6tisch-6top-protocol-03.
|
|
*
|
|
* The assumption here is that there is one transactions for a single peer at
|
|
* most.
|
|
*/
|
|
for(trans = list_head(trans_list);
|
|
trans != NULL; trans = trans->next) {
|
|
if(memcmp(peer_addr, &trans->peer_addr, sizeof(linkaddr_t)) == 0) {
|
|
return trans;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
int
|
|
sixp_trans_init(void)
|
|
{
|
|
sixp_trans_t *trans, *next_trans;
|
|
|
|
/* make sure there's no timer task left before the initialization */
|
|
for(trans = list_head(trans_list);
|
|
trans != NULL; trans = next_trans) {
|
|
next_trans = trans->next;
|
|
ctimer_stop(&trans->timer);
|
|
free_trans(trans);
|
|
}
|
|
|
|
list_init(trans_list);
|
|
memb_init(&trans_memb);
|
|
return 0;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @} */
|