/*---------------------------------------------------------------------------*/
uip_ds6_nbr_t *
uip_ds6_get_least_lifetime_neighbor(void)
{
uip_ds6_nbr_t *nbr = nbr_table_head(ds6_neighbors);
uip_ds6_nbr_t *nbr_expiring = NULL;
while(nbr != NULL) {
if(nbr_expiring != NULL) {
clock_time_t curr = stimer_remaining(&nbr->reachable);
if(curr < stimer_remaining(&nbr->reachable)) {
nbr_expiring = nbr;
}
} else {
nbr_expiring = nbr;
}
nbr = nbr_table_next(ds6_neighbors, nbr);
}
return nbr_expiring;
}
/*---------------------------------------------------------------------------*/
uip_ds6_nbr_t *
uip_ds6_get_least_lifetime_neighbor(void)
{
uip_ds6_nbr_t *nbr_expiring = NULL;
uint8_t i;
for(i = 0; i < UIP_DS6_NBR_NB; i++) {
if(uip_ds6_nbr_cache[i].isused) {
if(nbr_expiring != NULL) {
time_t curr = stimer_remaining(&uip_ds6_nbr_cache[i].reachable);
if(curr < stimer_remaining(&nbr_expiring->reachable)) {
nbr_expiring = &uip_ds6_nbr_cache[i];
}
} else {
nbr_expiring = &uip_ds6_nbr_cache[i];
}
}
}
return nbr_expiring;
}
PROCESS_THREAD(rest_manager_process, ev, data)
{
PROCESS_BEGIN();
/*start the coap or http server*/
process_start(SERVER_PROCESS, NULL);
PROCESS_PAUSE();
/*Periodic resources are only available to COAP implementation*/
#ifdef WITH_COAP
periodic_resource_t* periodic_resource = NULL;
for (periodic_resource = (periodic_resource_t*)list_head(restful_periodic_services); periodic_resource; periodic_resource = periodic_resource->next) {
if (periodic_resource->period) {
PRINTF("Set timer for Res: %s to %lu\n", periodic_resource->resource->url, periodic_resource->period);
etimer_set(periodic_resource->handler_cb_timer, periodic_resource->period);
}
}
while(1) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_TIMER) {
for (periodic_resource = (periodic_resource_t*)list_head(restful_periodic_services);periodic_resource;periodic_resource = periodic_resource->next) {
if (periodic_resource->period && etimer_expired(periodic_resource->handler_cb_timer)) {
PRINTF("Etimer expired for %s (period:%lu life:%lu)\n", periodic_resource->resource->url, periodic_resource->period, periodic_resource->lifetime);
/*call the periodic handler function if exists*/
if (periodic_resource->periodic_handler) {
if ((periodic_resource->periodic_handler)(periodic_resource->resource)) {
PRINTF("RES CHANGE\n");
if (!stimer_expired(periodic_resource->lifetime_timer)) {
PRINTF("TIMER NOT EXPIRED\n");
resource_changed(periodic_resource);
periodic_resource->lifetime = stimer_remaining(periodic_resource->lifetime_timer);
} else {
periodic_resource->lifetime = 0;
}
}
PRINTF("%s lifetime %lu (%lu) expired %d\n", periodic_resource->resource->url, stimer_remaining(periodic_resource->lifetime_timer), periodic_resource->lifetime, stimer_expired(periodic_resource->lifetime_timer));
}
etimer_reset(periodic_resource->handler_cb_timer);
}
}
}
}
#endif /*WITH_COAP*/
PROCESS_END();
}
void
uip_ds6_send_ra_sollicited(void)
{
/* We have a pb here: RA timer max possible value is 1800s,
* hence we have to use stimers. However, when receiving a RS, we
* should delay the reply by a random value between 0 and 500ms timers.
* stimers are in seconds, hence we cannot do this. Therefore we just send
* the RA (setting the timer to 0 below). We keep the code logic for
* the days contiki will support appropriate timers */
rand_time = 0;
PRINTF("Solicited RA, random time %u\n", rand_time);
if(stimer_remaining(&uip_ds6_timer_ra) > rand_time) {
if(stimer_elapsed(&uip_ds6_timer_ra) < UIP_ND6_MIN_DELAY_BETWEEN_RAS) {
/* Ensure that the RAs are rate limited */
/* stimer_set(&uip_ds6_timer_ra, rand_time +
UIP_ND6_MIN_DELAY_BETWEEN_RAS -
stimer_elapsed(&uip_ds6_timer_ra));
*/ } else {
stimer_set(&uip_ds6_timer_ra, rand_time);
}
}
}
/*
* Process a Router Advertisement
*
* - Possible actions when receiving a RA: add router to router list,
* recalculate reachable time, update link hop limit, update retrans timer.
* - If MTU option: update MTU.
* - If SLLAO option: update entry in neighbor cache
* - If prefix option: start autoconf, add prefix to prefix list
*/
void
ra_input(void)
{
PRINTF("Received RA from");
PRINT6ADDR(&UIP_IP_BUF->srcipaddr);
PRINTF("to");
PRINT6ADDR(&UIP_IP_BUF->destipaddr);
PRINTF("\n");
UIP_STAT(++uip_stat.nd6.recv);
#if UIP_CONF_IPV6_CHECKS
if((UIP_IP_BUF->ttl != UIP_ND6_HOP_LIMIT) ||
(!uip_is_addr_link_local(&UIP_IP_BUF->srcipaddr)) ||
(UIP_ICMP_BUF->icode != 0)) {
PRINTF("RA received is bad");
goto discard;
}
#endif /*UIP_CONF_IPV6_CHECKS */
if(UIP_ND6_RA_BUF->cur_ttl != 0) {
uip_ds6_if.cur_hop_limit = UIP_ND6_RA_BUF->cur_ttl;
PRINTF("uip_ds6_if.cur_hop_limit %u\n", uip_ds6_if.cur_hop_limit);
}
if(UIP_ND6_RA_BUF->reachable_time != 0) {
if(uip_ds6_if.base_reachable_time !=
uip_ntohl(UIP_ND6_RA_BUF->reachable_time)) {
uip_ds6_if.base_reachable_time = uip_ntohl(UIP_ND6_RA_BUF->reachable_time);
uip_ds6_if.reachable_time = uip_ds6_compute_reachable_time();
}
}
if(UIP_ND6_RA_BUF->retrans_timer != 0) {
uip_ds6_if.retrans_timer = uip_ntohl(UIP_ND6_RA_BUF->retrans_timer);
}
/* Options processing */
nd6_opt_offset = UIP_ND6_RA_LEN;
while(uip_l3_icmp_hdr_len + nd6_opt_offset < uip_len) {
if(UIP_ND6_OPT_HDR_BUF->len == 0) {
PRINTF("RA received is bad");
goto discard;
}
switch (UIP_ND6_OPT_HDR_BUF->type) {
case UIP_ND6_OPT_SLLAO:
PRINTF("Processing SLLAO option in RA\n");
nd6_opt_llao = (uint8_t *) UIP_ND6_OPT_HDR_BUF;
nbr = uip_ds6_nbr_lookup(&UIP_IP_BUF->srcipaddr);
if(nbr == NULL) {
nbr = uip_ds6_nbr_add(&UIP_IP_BUF->srcipaddr,
(uip_lladdr_t *)&nd6_opt_llao[UIP_ND6_OPT_DATA_OFFSET],
1, NBR_STALE);
} else {
uip_lladdr_t *lladdr = uip_ds6_nbr_get_ll(nbr);
if(nbr->state == NBR_INCOMPLETE) {
nbr->state = NBR_STALE;
}
if(memcmp(&nd6_opt_llao[UIP_ND6_OPT_DATA_OFFSET],
lladdr, UIP_LLADDR_LEN) != 0) {
memcpy(lladdr, &nd6_opt_llao[UIP_ND6_OPT_DATA_OFFSET],
UIP_LLADDR_LEN);
nbr->state = NBR_STALE;
}
nbr->isrouter = 1;
}
break;
case UIP_ND6_OPT_MTU:
PRINTF("Processing MTU option in RA\n");
uip_ds6_if.link_mtu =
uip_ntohl(((uip_nd6_opt_mtu *) UIP_ND6_OPT_HDR_BUF)->mtu);
break;
case UIP_ND6_OPT_PREFIX_INFO:
PRINTF("Processing PREFIX option in RA\n");
nd6_opt_prefix_info = (uip_nd6_opt_prefix_info *) UIP_ND6_OPT_HDR_BUF;
if((uip_ntohl(nd6_opt_prefix_info->validlt) >=
uip_ntohl(nd6_opt_prefix_info->preferredlt))
&& (!uip_is_addr_link_local(&nd6_opt_prefix_info->prefix))) {
/* on-link flag related processing */
if(nd6_opt_prefix_info->flagsreserved1 & UIP_ND6_RA_FLAG_ONLINK) {
prefix =
uip_ds6_prefix_lookup(&nd6_opt_prefix_info->prefix,
nd6_opt_prefix_info->preflen);
if(prefix == NULL) {
if(nd6_opt_prefix_info->validlt != 0) {
if(nd6_opt_prefix_info->validlt != UIP_ND6_INFINITE_LIFETIME) {
prefix = uip_ds6_prefix_add(&nd6_opt_prefix_info->prefix,
nd6_opt_prefix_info->preflen,
uip_ntohl(nd6_opt_prefix_info->
validlt));
} else {
prefix = uip_ds6_prefix_add(&nd6_opt_prefix_info->prefix,
nd6_opt_prefix_info->preflen, 0);
}
}
} else {
switch (nd6_opt_prefix_info->validlt) {
case 0:
uip_ds6_prefix_rm(prefix);
break;
case UIP_ND6_INFINITE_LIFETIME:
prefix->isinfinite = 1;
break;
default:
PRINTF("Updating timer of prefix");
PRINT6ADDR(&prefix->ipaddr);
PRINTF("new value %lu\n", uip_ntohl(nd6_opt_prefix_info->validlt));
stimer_set(&prefix->vlifetime,
uip_ntohl(nd6_opt_prefix_info->validlt));
prefix->isinfinite = 0;
break;
}
}
}
/* End of on-link flag related processing */
/* autonomous flag related processing */
if((nd6_opt_prefix_info->flagsreserved1 & UIP_ND6_RA_FLAG_AUTONOMOUS)
&& (nd6_opt_prefix_info->validlt != 0)
&& (nd6_opt_prefix_info->preflen == UIP_DEFAULT_PREFIX_LEN)) {
uip_ipaddr_copy(&ipaddr, &nd6_opt_prefix_info->prefix);
uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr);
addr = uip_ds6_addr_lookup(&ipaddr);
if((addr != NULL) && (addr->type == ADDR_AUTOCONF)) {
if(nd6_opt_prefix_info->validlt != UIP_ND6_INFINITE_LIFETIME) {
/* The processing below is defined in RFC4862 section 5.5.3 e */
if((uip_ntohl(nd6_opt_prefix_info->validlt) > 2 * 60 * 60) ||
(uip_ntohl(nd6_opt_prefix_info->validlt) >
stimer_remaining(&addr->vlifetime))) {
PRINTF("Updating timer of address");
PRINT6ADDR(&addr->ipaddr);
PRINTF("new value %lu\n",
uip_ntohl(nd6_opt_prefix_info->validlt));
stimer_set(&addr->vlifetime,
uip_ntohl(nd6_opt_prefix_info->validlt));
} else {
stimer_set(&addr->vlifetime, 2 * 60 * 60);
PRINTF("Updating timer of address ");
PRINT6ADDR(&addr->ipaddr);
PRINTF("new value %lu\n", (unsigned long)(2 * 60 * 60));
}
addr->isinfinite = 0;
} else {
addr->isinfinite = 1;
}
} else {
if(uip_ntohl(nd6_opt_prefix_info->validlt) ==
UIP_ND6_INFINITE_LIFETIME) {
uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF);
} else {
uip_ds6_addr_add(&ipaddr, uip_ntohl(nd6_opt_prefix_info->validlt),
ADDR_AUTOCONF);
}
}
}
/* End of autonomous flag related processing */
}
break;
default:
PRINTF("ND option not supported in RA");
break;
}
nd6_opt_offset += (UIP_ND6_OPT_HDR_BUF->len << 3);
}
defrt = uip_ds6_defrt_lookup(&UIP_IP_BUF->srcipaddr);
if(UIP_ND6_RA_BUF->router_lifetime != 0) {
if(nbr != NULL) {
nbr->isrouter = 1;
}
if(defrt == NULL) {
uip_ds6_defrt_add(&UIP_IP_BUF->srcipaddr,
(unsigned
long)(uip_ntohs(UIP_ND6_RA_BUF->router_lifetime)));
} else {
stimer_set(&(defrt->lifetime),
(unsigned long)(uip_ntohs(UIP_ND6_RA_BUF->router_lifetime)));
}
} else {
if(defrt != NULL) {
uip_ds6_defrt_rm(defrt);
}
}
#if UIP_CONF_IPV6_QUEUE_PKT
/* If the nbr just became reachable (e.g. it was in NBR_INCOMPLETE state
* and we got a SLLAO), check if we had buffered a pkt for it */
/* if((nbr != NULL) && (nbr->queue_buf_len != 0)) {
uip_len = nbr->queue_buf_len;
memcpy(UIP_IP_BUF, nbr->queue_buf, uip_len);
nbr->queue_buf_len = 0;
return;
}*/
if(nbr != NULL && uip_packetqueue_buflen(&nbr->packethandle) != 0) {
uip_len = uip_packetqueue_buflen(&nbr->packethandle);
memcpy(UIP_IP_BUF, uip_packetqueue_buf(&nbr->packethandle), uip_len);
uip_packetqueue_free(&nbr->packethandle);
return;
}
#endif /*UIP_CONF_IPV6_QUEUE_PKT */
discard:
uip_len = 0;
return;
}
static
PT_THREAD(generate_network(struct httpd_state *s))
{
static int i;
static uip_ds6_route_t *r;
static uip_ds6_defrt_t *dr;
#if BUF_USES_STACK
char buf[BUF_SIZE];
#endif
#if WEBSERVER_CONF_LOADTIME
static clock_time_t numticks;
numticks = clock_time();
#endif
PSOCK_BEGIN(&s->sout);
SEND_STRING(&s->sout, TOP);
if(redirect) {
//Quick hack to rewrite url after route or neighbour removal
SEND_STRING(&s->sout,
"<meta http-equiv=\"refresh\" content=\"0; url=/network.html\" />");
}
SEND_STRING(&s->sout, BODY);
reset_buf();
add_div_home("Network");
add("<div id=\"left_home\">");
add("<br /><h2>Addresses</h2><pre>");
SEND_STRING(&s->sout, buf);
reset_buf();
for(i = 0; i < UIP_DS6_ADDR_NB; i++) {
if(uip_ds6_if.addr_list[i].isused) {
ipaddr_add(&uip_ds6_if.addr_list[i].ipaddr);
char flag;
if(uip_ds6_if.addr_list[i].state == ADDR_TENTATIVE) {
flag = 'T';
} else if(uip_ds6_if.addr_list[i].state == ADDR_PREFERRED) {
flag = 'P';
} else {
flag = '?';
}
add(" %c", flag);
if(uip_ds6_if.addr_list[i].type == ADDR_MANUAL) {
flag = 'M';
} else if(uip_ds6_if.addr_list[i].type == ADDR_DHCP) {
flag = 'D';
} else if(uip_ds6_if.addr_list[i].type == ADDR_AUTOCONF) {
flag = 'A';
} else {
flag = '?';
}
add(" %c", flag);
if(!uip_ds6_if.addr_list[i].isinfinite) {
add(" %u s", stimer_remaining(&uip_ds6_if.addr_list[i].vlifetime));
}
add("\n");
SEND_STRING(&s->sout, buf);
reset_buf();
}
}
add("</pre><h2>Prefixes</h2><pre>");
for(i = 0; i < UIP_DS6_PREFIX_NB; i++) {
if(uip_ds6_prefix_list[i].isused) {
ipaddr_add(&uip_ds6_prefix_list[i].ipaddr);
add(" ");
#if UIP_CONF_ROUTER
if(uip_ds6_prefix_list[i].advertise) {
add("A");
}
#else
if(uip_ds6_prefix_list[i].isinfinite) {
add("I");
}
#endif
add("\n");
}
}
SEND_STRING(&s->sout, buf);
reset_buf();
add("</pre><h2>Neighbors</h2><pre>");
for(i = 0; i < UIP_DS6_NBR_NB; i++) {
if(uip_ds6_nbr_cache[i].isused) {
if ((nvm_data.global_flags & CETIC_GLOBAL_DISABLE_CONFIG) == 0) {
add("[<a href=\"nbr_rm?%d\">del</a>] ", i);
}
ipaddr_add(&uip_ds6_nbr_cache[i].ipaddr);
add(" ");
lladdr_add(&uip_ds6_nbr_cache[i].lladdr);
add(" ");
add_network_cases(uip_ds6_nbr_cache[i].state);
add("\n");
SEND_STRING(&s->sout, buf);
reset_buf();
}
}
add("</pre><h2>Routes</h2><pre>");
SEND_STRING(&s->sout, buf);
reset_buf();
for(r = uip_ds6_route_list_head(), i = 0; r != NULL;
r = list_item_next(r), ++i) {
if ((nvm_data.global_flags & CETIC_GLOBAL_DISABLE_CONFIG) == 0) {
add("[<a href=\"route_rm?%d\">del</a>] ", i);
}
ipaddr_add(&r->ipaddr);
add("/%u (via ", r->length);
ipaddr_add(&r->nexthop);
if(1 || (r->state.lifetime < 600)) {
add(") %lu s\n", r->state.lifetime);
} else {
add(")\n");
}
SEND_STRING(&s->sout, buf);
reset_buf();
}
add("</pre><h2>Default Routers</h2><pre>");
for(dr = uip_ds6_defrt_list_head(); dr != NULL; dr = list_item_next(r)) {
ipaddr_add(&dr->ipaddr);
if(!dr->isinfinite) {
add(" %u s", stimer_remaining(&dr->lifetime));
}
add("\n");
SEND_STRING(&s->sout, buf);
reset_buf();
}
#if UIP_CONF_DS6_ROUTE_INFORMATION
add("</pre><h2>Route info</h2><pre>");
for(i = 0; i < UIP_DS6_ROUTE_INFO_NB; i++) {
if(uip_ds6_route_info_list[i].isused) {
ipaddr_add(&uip_ds6_route_info_list[i].ipaddr);
add("/%u (%x) %us\n", uip_ds6_route_info_list[i].length,
uip_ds6_route_info_list[i].flags,
uip_ds6_route_info_list[i].lifetime);
}
}
SEND_STRING(&s->sout, buf);
reset_buf();
#endif
#if CETIC_6LBR_TRANSPARENTBRIDGE
add("</pre><h2>HW Prefixes cache</h2><pre>");
for(i = 0; i < prefixCounter; i++) {
add("%02x:%02x:%02x\n", prefixBuffer[i][0], prefixBuffer[i][1],
prefixBuffer[i][2]);
}
SEND_STRING(&s->sout, buf);
reset_buf();
add("</pre><br />");
#endif
add_div_footer();
#if WEBSERVER_CONF_FILESTATS
static uint16_t numtimes;
add("<br><i>This page sent %u times</i>", ++numtimes);
#endif
#if WEBSERVER_CONF_LOADTIME
numticks = clock_time() - numticks + 1;
add(" <i>(%u.%02u sec)</i>", numticks / CLOCK_SECOND,
(100 * (numticks % CLOCK_SECOND) / CLOCK_SECOND));
#endif
add("</div></div>");
SEND_STRING(&s->sout, buf);
SEND_STRING(&s->sout, BOTTOM);
PSOCK_END(&s->sout);
}
/*---------------------------------------------------------------------------*/
void
uip_ds6_periodic(void)
{
/* This flag signals whether we allow or not to send a packet in the current
* invocation. */
u8_t allow_output = 1;
/* minimum lifetime */
min_lifetime = 0xFFFFFFFF;
/* router with minimum lifetime */
min_defrt = NULL;
/* Periodic processing on registrations */
for(locreg = uip_ds6_reg_list;
locreg < uip_ds6_reg_list + UIP_DS6_REG_LIST_SIZE; locreg++) {
if (locreg->isused) {
if (stimer_expired(&locreg->reg_lifetime)) {
uip_ds6_reg_rm(locreg);
} else if (allow_output) {
/* If no output is allowed, it is pointless to enter here in this invocation */
if (uip_ds6_if.registration_in_progress) {
/* There is a registration in progress */
if ((locreg == uip_ds6_if.registration_in_progress) &&
(timer_expired(&locreg->registration_timer))) {
/* We already sent a NS message for this address but there has been no response */
if(locreg->reg_count >= UIP_ND6_MAX_UNICAST_SOLICIT) {
/* NUD failed. Signal the need for next-hop determination by deleting the
* NCE (RFC 4861) */
uip_ds6_reg_rm(locreg);
/* And then, delete neighbor and corresponding router (as hosts only keep
* NCEs for routers in 6lowpan-nd) */
locnbr = uip_ds6_nbr_lookup(&locreg->defrt->ipaddr);
uip_ds6_nbr_rm(locnbr);
uip_ds6_defrt_rm(locreg->defrt);
/* Since we are deleting a default router, we must delete also all
* registrations with that router.
* Be careful here, uip_ds6_reg_cleanup_defrt() modifies the value of locreg!*/
uip_ds6_reg_cleanup_defrt(locreg->defrt);
/* We will also need to start sending RS, as specified in I-D.ietf-6lowpan-nd
* for NUD failure case */
uip_ds6_send_rs(NULL);
uip_ds6_if.registration_in_progress = NULL;
} else {
locreg->reg_count++;
timer_restart(&locreg->registration_timer);
uip_nd6_ns_output(&locreg->addr->ipaddr, &locreg->defrt->ipaddr,
&locreg->defrt->ipaddr, 1, UIP_ND6_REGISTRATION_LIFETIME);
}
allow_output = 0; /* Prevent this invocation from sending anything else */
}
} else {
/* There are no registrations in progress, let's see this entry needs (re)registration
* or deletion */
if ((locreg->state == REG_GARBAGE_COLLECTIBLE) ||
(locreg->state == REG_TO_BE_UNREGISTERED) ||
((locreg->state == REG_REGISTERED) &&
(stimer_remaining(&locreg->reg_lifetime) < stimer_elapsed(&locreg->reg_lifetime)))) {
/* Issue (re)registration */
uip_ds6_if.registration_in_progress = locreg;
locreg->reg_count++;
timer_set(&locreg->registration_timer, (uip_ds6_if.retrans_timer / 1000) * (CLOCK_SECOND /* FIXME @@@jwg!!!!*/+250));
if (locreg->state == REG_TO_BE_UNREGISTERED) {
uip_nd6_ns_output(&locreg->addr->ipaddr, &locreg->defrt->ipaddr,
&locreg->defrt->ipaddr, 1, 0);
} else {
uip_nd6_ns_output(&locreg->addr->ipaddr, &locreg->defrt->ipaddr,
&locreg->defrt->ipaddr, 1, UIP_ND6_REGISTRATION_LIFETIME);
}
allow_output = 0; /* Prevent this invocation from sending anything else */
}
}
}
}
}
/* Periodic processing on unicast addresses */
for(locaddr = uip_ds6_if.addr_list;
locaddr < uip_ds6_if.addr_list + UIP_DS6_ADDR_NB; locaddr++) {
if(locaddr->isused) {
if((!locaddr->isinfinite) && (stimer_expired(&locaddr->vlifetime))) {
uip_ds6_addr_rm(locaddr);
} else if (allow_output) {
if (stimer_remaining(&locaddr->vlifetime) < min_lifetime) {
min_lifetime = stimer_remaining(&locaddr->vlifetime);
min_defrt = locaddr->defrt;
}
}
}
}
/* Periodic processing on default routers */
if (uip_ds6_defrt_choose() == NULL) {
if (allow_output) {
/* If default router list is empty, start sending RS */
uip_ds6_send_rs(NULL);
allow_output = 0; /* Prevent this invocation from sending anything else */
}
} else {
for(locdefrt = uip_ds6_defrt_list;
locdefrt < uip_ds6_defrt_list + UIP_DS6_DEFRT_NB; locdefrt++) {
if((locdefrt->isused) && (!locdefrt->isinfinite)) {
if (stimer_expired(&(locdefrt->lifetime))) {
uip_ds6_defrt_rm(locdefrt);
/* If default router list is empty, we will start sending RS in
* the next invocation of ds6_periodic() */
} else {
if (allow_output) {
if (stimer_remaining(&locdefrt->lifetime) < min_lifetime) {
min_lifetime = stimer_remaining(&locdefrt->lifetime);
min_defrt = locdefrt;
}
}
}
}
}
}
#if !UIP_CONF_ROUTER
/* Periodic processing on prefixes */
for (locprefix = uip_ds6_prefix_list;
locprefix < uip_ds6_prefix_list + UIP_DS6_PREFIX_NB; locprefix++) {
if((locprefix->isused) && (!locprefix->isinfinite)) {
if (stimer_expired(&locprefix->vlifetime)) {
uip_ds6_prefix_rm(locprefix);
} else if (allow_output) {
if (stimer_remaining(&locprefix->vlifetime) < min_lifetime) {
min_lifetime = stimer_remaining(&locprefix->vlifetime);
min_defrt = locprefix->defrt;
}
}
}
}
#endif /* !UIP_CONF_ROUTER */
#if CONF_6LOWPAN_ND_6CO
/* Periodic processing on contexts */
for(loccontext = uip_ds6_addr_context_table;
loccontext < uip_ds6_addr_context_table + SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS; loccontext++) {
if(loccontext->state != NOT_IN_USE) {
if (stimer_expired(&loccontext->vlifetime)) {
if (loccontext->state != EXPIRED) {
loccontext->state = IN_USE_UNCOMPRESS_ONLY;
stimer_set(&loccontext->vlifetime, 2 * loccontext->defrt_lifetime);
} else {
uip_ds6_context_rm(loccontext);
}
} else if (allow_output) {
if (stimer_remaining(&loccontext->vlifetime) < min_lifetime) {
min_lifetime = stimer_remaining(&loccontext->vlifetime);
min_defrt = loccontext->defrt;
}
}
}
}
#endif /* CONF_6LOWPAN_ND_6CO */
/* Start sending RS well before the minimum of the lifetimes (def. router,
* context, or prefix) expires */
if ((allow_output) && (min_lifetime < UIP_DS6_LIFETIME_THRESHOLD)) {
/* Start sending RSs to the router with minimum lifetime (if possible) */
uip_ds6_send_rs(min_defrt);
allow_output = 0;
}
/* Periodic processing on neighbors */
for(locnbr = uip_ds6_nbr_cache; locnbr < uip_ds6_nbr_cache + UIP_DS6_NBR_NB;
locnbr++) {
if(locnbr->isused) {
switch (locnbr->state) {
#if UIP_CONF_ROUTER
/* There can not be INCOMPLETE NCEs in a host in 6lowpan-nd */
case NBR_INCOMPLETE:
if (allow_output) {
if(locnbr->nscount >= UIP_ND6_MAX_MULTICAST_SOLICIT) {
uip_ds6_nbr_rm(locnbr);
} else if(stimer_expired(&(locnbr->sendns))) {
locnbr->nscount++;
PRINTF("NBR_INCOMPLETE: NS %u\n", locnbr->nscount);
uip_nd6_ns_output(NULL, NULL, &locnbr->ipaddr);
stimer_set(&(locnbr->sendns), uip_ds6_if.retrans_timer / 1000);
allow_output = 0;
}
}
break;
#endif /* UIP_CONF_ROUTER */
case NBR_REACHABLE:
if(stimer_expired(&(locnbr->reachable))) {
PRINTF("REACHABLE: moving to STALE (");
PRINT6ADDR(&locnbr->ipaddr);
PRINTF(")\n");
locnbr->state = NBR_STALE;
NEIGHBOR_STATE_CHANGED(locnbr);
}
break;
case NBR_DELAY:
if (allow_output) {
if(stimer_expired(&(locnbr->reachable))) {
locnbr->state = NBR_PROBE;
locnbr->nscount = 1;
NEIGHBOR_STATE_CHANGED(locnbr);
PRINTF("DELAY: moving to PROBE + NS %u\n", locnbr->nscount);
uip_nd6_ns_output(NULL, &locnbr->ipaddr, &locnbr->ipaddr, 0, 0);
stimer_set(&(locnbr->sendns), uip_ds6_if.retrans_timer / 1000);
allow_output = 0;
}
}
break;
case NBR_PROBE:
if (allow_output) {
if(locnbr->nscount >= UIP_ND6_MAX_UNICAST_SOLICIT) {
PRINTF("PROBE END \n");
if((locdefrt = uip_ds6_defrt_lookup(&locnbr->ipaddr)) != NULL) {
uip_ds6_defrt_rm(locdefrt);
}
uip_ds6_nbr_rm(locnbr);
} else if(stimer_expired(&(locnbr->sendns))) {
locnbr->nscount++;
PRINTF("PROBE: NS %u\n", locnbr->nscount);
uip_nd6_ns_output(NULL, &locnbr->ipaddr, &locnbr->ipaddr, 0, 0);
stimer_set(&(locnbr->sendns), uip_ds6_if.retrans_timer / 1000);
allow_output = 0;
}
}
break;
default:
break;
}
}
}
#if UIP_CONF_ROUTER & UIP_ND6_SEND_RA
/* Periodic RA sending */
if(stimer_expired(&uip_ds6_timer_ra)) {
uip_ds6_send_ra_periodic();
}
#endif /* UIP_CONF_ROUTER & UIP_ND6_SEND_RA */
etimer_reset(&uip_ds6_timer_periodic);
return;
}
static
PT_THREAD(generate_network(struct httpd_state *s))
{
static int i;
static uip_ds6_route_t *r;
static uip_ds6_defrt_t *dr;
static uip_ds6_nbr_t *nbr;
#if CETIC_6LBR_WITH_MULTICAST
static uip_mcast6_route_t *mcast_route;
#endif
#if RPL_WITH_NON_STORING
static rpl_ns_node_t *link;
#endif
PSOCK_BEGIN(&s->sout);
add("<br /><h2>Addresses</h2><pre>");
SEND_STRING(&s->sout, buf);
reset_buf();
for(i = 0; i < UIP_DS6_ADDR_NB; i++) {
if(uip_ds6_if.addr_list[i].isused) {
ipaddr_add(&uip_ds6_if.addr_list[i].ipaddr);
add(" ");
add_address_type(uip_ds6_if.addr_list[i].type);
add(" ");
add_address_state(uip_ds6_if.addr_list[i].state);
if(!uip_ds6_if.addr_list[i].isinfinite) {
add(" %u s", stimer_remaining(&uip_ds6_if.addr_list[i].vlifetime));
}
add("\n");
SEND_STRING(&s->sout, buf);
reset_buf();
}
}
add("</pre><h2>Multicast groups</h2><pre>");
for(i = 0; i < UIP_DS6_MADDR_NB; i++) {
if(uip_ds6_if.maddr_list[i].isused) {
ipaddr_add(&uip_ds6_if.maddr_list[i].ipaddr);
add("\n");
SEND_STRING(&s->sout, buf);
reset_buf();
}
}
add("</pre><h2>Prefixes</h2><pre>");
for(i = 0; i < UIP_DS6_PREFIX_NB; i++) {
if(uip_ds6_prefix_list[i].isused) {
ipaddr_add(&uip_ds6_prefix_list[i].ipaddr);
#if UIP_CONF_ROUTER
if(uip_ds6_prefix_list[i].advertise) {
add(" Adv");
}
#else
if(uip_ds6_prefix_list[i].isinfinite) {
add(" Inf");
}
#endif
add("\n");
}
}
SEND_STRING(&s->sout, buf);
reset_buf();
#if CETIC_6LBR_WITH_IP64
if((nvm_data.global_flags & CETIC_GLOBAL_IP64) != 0) {
add("</pre><h2>IP64</h2><pre>");
if((nvm_data.eth_ip64_flags & CETIC_6LBR_IP64_DHCP) == 0 || ip64_hostaddr_is_configured()) {
add("Address : ");
ip4addr_add(ip64_get_hostaddr());
add("<br />");
add("Netmask : ");
ip4addr_add(ip64_get_netmask());
add("<br />");
add("Gateway : ");
ip4addr_add(ip64_get_draddr());
add("<br />");
if((nvm_data.eth_ip64_flags & CETIC_6LBR_IP64_DHCP) != 0) {
add("DHCP Server : ");
ip4addr_add_u8(cetic_6lbr_ip64_dhcp_state->serverid);
add("<br />");
add("DHCP lease time : %d s<br />",
uip_ntohs(cetic_6lbr_ip64_dhcp_state->lease_time[0])*65536ul + uip_ntohs(cetic_6lbr_ip64_dhcp_state->lease_time[1]));
}
} else {
add("Waiting configuration<br />");
}
SEND_STRING(&s->sout, buf);
reset_buf();
}
#endif
add("</pre><h2>Neighbors</h2><pre>");
for(nbr = nbr_table_head(ds6_neighbors);
nbr != NULL;
nbr = nbr_table_next(ds6_neighbors, nbr)) {
if ((nvm_data.global_flags & CETIC_GLOBAL_DISABLE_CONFIG) == 0) {
add("[<a href=\"nbr-rm?");
ipaddr_add(&nbr->ipaddr);
add("\">del</a>] ");
}
#if CETIC_6LBR_NODE_CONFIG_HAS_NAME
if ( node_config_loaded ) {
add("%s : ", node_config_get_name(node_config_find_by_lladdr(uip_ds6_nbr_get_ll(nbr))));
}
#endif
ipaddr_add(&nbr->ipaddr);
add(" ");
lladdr_add(uip_ds6_nbr_get_ll(nbr));
add(" ");
add_network_cases(nbr->state);
#if UIP_SWITCH_LOOKUP
if(nbr->ifindex != NETWORK_ITF_UNKNOWN) {
add(" if:%u", nbr->ifindex);
}
#endif
add("\n");
SEND_STRING(&s->sout, buf);
reset_buf();
}
add("</pre><h2>Routes</h2><pre>");
SEND_STRING(&s->sout, buf);
reset_buf();
for(r = uip_ds6_route_head(), i = 0; r != NULL;
r = uip_ds6_route_next(r), ++i) {
if ((nvm_data.global_flags & CETIC_GLOBAL_DISABLE_CONFIG) == 0) {
add("[<a href=\"route-rm?");
ipaddr_add(&r->ipaddr);
add("\">del</a>] ");
}
#if CETIC_6LBR_NODE_CONFIG_HAS_NAME
if ( node_config_loaded ) {
add("%s (", node_config_get_name(node_config_find_by_ip(&r->ipaddr)));
ipaddr_add(&r->ipaddr);
add("/%u) via ", r->length);
} else {
ipaddr_add(&r->ipaddr);
add("/%u via ", r->length);
}
if ( node_config_loaded ) {
add("%s (", node_config_get_name(node_config_find_by_ip(uip_ds6_route_nexthop(r))));
ipaddr_add(uip_ds6_route_nexthop(r));
add(")");
} else {
ipaddr_add(uip_ds6_route_nexthop(r));
}
#else
ipaddr_add(&r->ipaddr);
add("/%u via ", r->length);
ipaddr_add(uip_ds6_route_nexthop(r));
#endif
#if CETIC_6LBR_WITH_RPL
if(r->state.lifetime != RPL_ROUTE_INFINITE_LIFETIME) {
#else
if(r->neighbor_routes != NULL) {
#endif
add(" %lu s\n", r->state.lifetime);
} else {
add("Inf\n");
}
SEND_STRING(&s->sout, buf);
reset_buf();
}
#if RPL_WITH_NON_STORING
add("</pre><h2>Links</h2><pre>");
for(link = rpl_ns_node_head(); link != NULL; link = rpl_ns_node_next(link)) {
if(link->parent != NULL) {
uip_ipaddr_t child_ipaddr;
uip_ipaddr_t parent_ipaddr;
rpl_ns_get_node_global_addr(&child_ipaddr, link);
rpl_ns_get_node_global_addr(&parent_ipaddr, link->parent);
#if CETIC_6LBR_NODE_CONFIG_HAS_NAME
if ( node_config_loaded ) {
add("%s (", node_config_get_name(node_config_find_by_ip(&child_ipaddr)));
ipaddr_add(&child_ipaddr);
add(") via ");
} else {
ipaddr_add(&child_ipaddr);
add(" via ");
}
if ( node_config_loaded ) {
add("%s (", node_config_get_name(node_config_find_by_ip(&parent_ipaddr)));
ipaddr_add(&parent_ipaddr);
add(")");
} else {
ipaddr_add(&parent_ipaddr);
}
#else
ipaddr_add(&child_ipaddr);
add(" via ");
ipaddr_add(&parent_ipaddr);
#endif
add(" %lu s\n", link->lifetime);
SEND_STRING(&s->sout, buf);
reset_buf();
}
}
#endif
#if CETIC_6LBR_WITH_MULTICAST
add("</pre><h2>Routed multicast groups</h2><pre>");
for(mcast_route = uip_mcast6_route_list_head(), i = 0; mcast_route != NULL;
mcast_route = list_item_next(mcast_route), ++i) {
if ((nvm_data.global_flags & CETIC_GLOBAL_DISABLE_CONFIG) == 0) {
add("[<a href=\"mcast-rm?");
ipaddr_add(&mcast_route->group);
add("\">del</a>] ");
}
ipaddr_add(&mcast_route->group);
add(" %lu s\n", mcast_route->lifetime);
SEND_STRING(&s->sout, buf);
reset_buf();
}
#endif
add("</pre><h2>Default Routers</h2><pre>");
for(dr = uip_ds6_defrt_head(); dr != NULL; dr = list_item_next(r)) {
ipaddr_add(&dr->ipaddr);
if(dr->isinfinite) {
add(" Inf");
} else {
add(" %u s", stimer_remaining(&dr->lifetime));
}
add("\n");
SEND_STRING(&s->sout, buf);
reset_buf();
}
#if UIP_CONF_DS6_ROUTE_INFORMATION
add("</pre><h2>Route info</h2><pre>");
for(i = 0; i < UIP_DS6_ROUTE_INFO_NB; i++) {
if(uip_ds6_route_info_list[i].isused) {
ipaddr_add(&uip_ds6_route_info_list[i].ipaddr);
add("/%u (%x) %u s\n", uip_ds6_route_info_list[i].length,
uip_ds6_route_info_list[i].flags,
uip_ds6_route_info_list[i].lifetime);
}
}
SEND_STRING(&s->sout, buf);
reset_buf();
#endif
add("</pre><h2>DNS server</h2><pre>");
//Note: Currently we assume only one DNS server
uip_ipaddr_t * dns = uip_nameserver_get(0);
if(!uip_is_addr_unspecified(dns)) {
ipaddr_add(dns);
add(" %u s\n", uip_nameserver_next_expiration());
}
SEND_STRING(&s->sout, buf);
reset_buf();
#if CETIC_6LBR_WITH_IP64
if((nvm_data.global_flags & CETIC_GLOBAL_IP64) != 0) {
add("</pre><h2>IP64 connections mapping</h2><pre>");
static struct ip64_addrmap_entry *m;
for(m = ip64_addrmap_list();
m != NULL;
m = list_item_next(m)) {
if(timer_expired(&m->timer)) continue;
ipaddr_add(&m->ip6addr);
add("%%%d (%d)", m->ip6port, m->protocol);
if(m->ip6to4 && m->ip4to6) {
add(" <-> ");
} else if(m->ip6to4) {
add(" -> ");
} else {
add(" <- ");
}
ip4addr_add(&m->ip4addr);
add("%%%d : %d (%x) %us\n", m->ip4port, m->mapped_port,
m->flags, (m->timer.interval - (clock_time() - m->timer.start)) / CLOCK_SECOND);
SEND_STRING(&s->sout, buf);
reset_buf();
}
}
#endif
#if SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS > 0
add("</pre><h2>6LoWPAN Prefix contexts</h2><pre>");
for(i = 0; i < SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS; i++) {
if(addr_contexts[i].used == 1) {
add("%d : ", addr_contexts[i].number);
ipaddr_add_u8_len(addr_contexts[i].prefix, 8);
add("\n");
}
}
add("</pre><br />");
SEND_STRING(&s->sout, buf);
reset_buf();
#endif
#if CETIC_6LBR_TRANSPARENTBRIDGE
add("<h2>HW Prefixes cache</h2><pre>");
for(i = 0; i < prefixCounter; i++) {
add("%02x:%02x:%02x\n", prefixBuffer[i][0], prefixBuffer[i][1],
prefixBuffer[i][2]);
}
SEND_STRING(&s->sout, buf);
add("</pre><br />");
reset_buf();
#endif
PSOCK_END(&s->sout);
}
static void
add_network_cases(const uint8_t state)
{
switch (state) {
case NBR_INCOMPLETE:
add("Incomplete");
break;
case NBR_REACHABLE:
add("Reachable");
break;
case NBR_STALE:
add("Stale");
break;
case NBR_DELAY:
add("Delay");
break;
case NBR_PROBE:
add("Probe");
break;
}
}
static httpd_cgi_call_t *
webserver_network_route_add(struct httpd_state *s)
{
#if UIP_DS6_STATIC_ROUTES
uip_ds6_route_t *route;
uip_ipaddr_t ipaddr;
uint8_t length;
uip_ipaddr_t nexthop;
char *p;
char *sep;
webserver_result_title = "Network";
webserver_result_text = "Add route: Route not created";
do {
if(!s->query) break;
p = s->query;
sep = index(p, '=');
if(sep == NULL) break;
*sep = 0;
if(strcmp(p, "target") != 0) break;
p = sep + 1;
sep = index(p, '&');
if(sep == NULL) break;
*sep = 0;
if(uiplib_ipaddrconv(p, &ipaddr) == 0) break;
p = sep + 1;
sep = index(p, '=');
if(sep == NULL) break;
*sep = 0;
if(strcmp(p, "length") != 0) break;
p = sep + 1;
sep = index(p, '&');
if(sep == NULL) break;
*sep = 0;
length = atoi(p);
p = sep + 1;
sep = index(p, '=');
if(sep == NULL) break;
*sep = 0;
if(strcmp(p, "nexthop") != 0) break;
p = sep + 1;
if(uiplib_ipaddrconv(p, &nexthop) == 0) break;
route = uip_ds6_route_add_static(&ipaddr, length, &nexthop);
if(route) {
webserver_result_text = "Route created";
}
} while (0);
#else
webserver_result_title = "Network";
webserver_result_text = "Add route: not supported";
#endif
return &webserver_result_page;
}
