/* Add a TSCH neighbor */
struct tsch_neighbor *
tsch_queue_add_nbr(const linkaddr_t *addr)
{
struct tsch_neighbor *n = NULL;
/* If we have an entry for this neighbor already, we simply update it */
n = tsch_queue_get_nbr(addr);
if(n == NULL) {
if(tsch_get_lock()) {
/* Allocate a neighbor */
n = memb_alloc(&neighbor_memb);
if(n != NULL) {
/* Initialize neighbor entry */
memset(n, 0, sizeof(struct tsch_neighbor));
ringbufindex_init(&n->tx_ringbuf, TSCH_QUEUE_NUM_PER_NEIGHBOR);
linkaddr_copy(&n->addr, addr);
n->is_broadcast = linkaddr_cmp(addr, &tsch_eb_address)
|| linkaddr_cmp(addr, &tsch_broadcast_address);
tsch_queue_backoff_reset(n);
/* Add neighbor to the list */
list_add(neighbor_list, n);
}
tsch_release_lock();
}
}
return n;
}
/*---------------------------------------------------------------------------*/
static void
packet_input(void)
{
#if DISCOVERY_AWARE_RDC_SEND_802154_ACK
int original_datalen;
uint8_t *original_dataptr;
original_datalen = packetbuf_datalen();
original_dataptr = packetbuf_dataptr();
#endif
#ifdef NETSTACK_DECRYPT
NETSTACK_DECRYPT();
#endif /* NETSTACK_DECRYPT */
#if DISCOVERY_AWARE_RDC_802154_AUTOACK
if(packetbuf_datalen() == ACK_LEN) {
/* Ignore ack packets */
PRINTF("RDC: ignored ack\n");
} else
#endif /* DISCOVERY_AWARE_RDC_802154_AUTOACK */
if(NETSTACK_FRAMER.parse() < 0) {
PRINTF("RDC: failed to parse %u\n", packetbuf_datalen());
#if DISCOVERY_AWARE_RDC_ADDRESS_FILTER
} else if(!linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_node_addr) &&
!linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_null)) {
PRINTF("RDC: not for us\n");
#endif /* DISCOVERY_AWARE_RDC_ADDRESS_FILTER */
} else {
#if DISCOVERY_AWARE_RDC_802154_AUTOACK || DISCOVERY_AWARE_RDC_802154_AUTOACK_HW
/* Check for duplicate packet by comparing the sequence number
of the incoming packet with the last few ones we saw. */
int i;
for(i = 0; i < MAX_SEQNOS; ++i) {
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_ID) == received_seqnos[i].seqno &&
linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER),
&received_seqnos[i].sender)) {
/* Drop the packet. */
return;
}
}
for(i = MAX_SEQNOS - 1; i > 0; --i) {
memcpy(&received_seqnos[i], &received_seqnos[i - 1],
sizeof(struct seqno));
}
received_seqnos[0].seqno = packetbuf_attr(PACKETBUF_ATTR_PACKET_ID);
linkaddr_copy(&received_seqnos[0].sender,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
#endif /* DISCOVERY_AWARE_RDC_802154_AUTOACK */
if (!linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &linkaddr_null)) {
to_modifier += 10;
rec_flag = 1;
}
NETSTACK_MAC.input();
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_collect_process, ev, data)
{
static struct etimer periodic;
static struct etimer et;
PROCESS_BEGIN();
collect_open(&tc, 130, COLLECT_ROUTER, &callbacks);
if(linkaddr_node_addr.u8[0] == 1 &&
linkaddr_node_addr.u8[1] == 0) {
printf("I am sink\n");
collect_set_sink(&tc, 1);
}
/* Allow some time for the network to settle. */
etimer_set(&et, 120 * CLOCK_SECOND);
PROCESS_WAIT_UNTIL(etimer_expired(&et));
while(1) {
/* Send a packet every 30 seconds. */
if(etimer_expired(&periodic)) {
etimer_set(&periodic, CLOCK_SECOND * 30);
etimer_set(&et, random_rand() % (CLOCK_SECOND * 30));
}
PROCESS_WAIT_EVENT();
if(etimer_expired(&et)) {
static linkaddr_t oldparent;
const linkaddr_t *parent;
printf("Sending\n");
packetbuf_clear();
packetbuf_set_datalen(sprintf(packetbuf_dataptr(),
"%s", "Hello") + 1);
collect_send(&tc, 15);
parent = collect_parent(&tc);
if(!linkaddr_cmp(parent, &oldparent)) {
if(!linkaddr_cmp(&oldparent, &linkaddr_null)) {
printf("#L %d 0\n", oldparent.u8[0]);
}
if(!linkaddr_cmp(parent, &linkaddr_null)) {
printf("#L %d 1\n", parent->u8[0]);
}
linkaddr_copy(&oldparent, parent);
}
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static int
rreq_packet_received(struct netflood_conn *nf, const linkaddr_t *from,
const linkaddr_t *originator, uint8_t seqno, uint8_t hops)
{
struct route_msg *msg = packetbuf_dataptr();
struct route_discovery_conn *c = (struct route_discovery_conn *)
((char *)nf - offsetof(struct route_discovery_conn, rreqconn));
PRINTF("%d.%d: rreq_packet_received from %d.%d hops %d rreq_id %d last %d.%d/%d\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1],
from->u8[0], from->u8[1],
hops, msg->rreq_id,
c->last_rreq_originator.u8[0],
c->last_rreq_originator.u8[1],
c->last_rreq_id);
if(!(linkaddr_cmp(&c->last_rreq_originator, originator) &&
c->last_rreq_id == msg->rreq_id)) {
PRINTF("%d.%d: rreq_packet_received: request for %d.%d originator %d.%d / %d\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1],
msg->dest.u8[0], msg->dest.u8[1],
originator->u8[0], originator->u8[1],
msg->rreq_id);
linkaddr_copy(&c->last_rreq_originator, originator);
c->last_rreq_id = msg->rreq_id;
if(linkaddr_cmp(&msg->dest, &linkaddr_node_addr)) {
PRINTF("%d.%d: route_packet_received: route request for our address\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1]);
PRINTF("from %d.%d hops %d rssi %d lqi %d\n",
from->u8[0], from->u8[1],
hops,
packetbuf_attr(PACKETBUF_ATTR_RSSI),
packetbuf_attr(PACKETBUF_ATTR_LINK_QUALITY));
insert_route(originator, from, hops);
/* Send route reply back to source. */
send_rrep(c, originator);
return 0; /* Don't continue to flood the rreq packet. */
} else {
/* PRINTF("route request for %d\n", msg->dest_id);*/
PRINTF("from %d.%d hops %d rssi %d lqi %d\n",
from->u8[0], from->u8[1],
hops,
packetbuf_attr(PACKETBUF_ATTR_RSSI),
packetbuf_attr(PACKETBUF_ATTR_LINK_QUALITY));
insert_route(originator, from, hops);
}
return 1;
}
return 0; /* Don't forward packet. */
}
/*---------------------------------------------------------------------------*/
static void
fast_c_packet_sent(int mac_status)
{
/* Check if our parent just ACKed a DAO */
if(fast_c_parent_knows_us == 0
&& mac_status == MAC_TX_OK
&& packetbuf_attr(PACKETBUF_ATTR_NETWORK_ID) == UIP_PROTO_ICMP6
&& packetbuf_attr(PACKETBUF_ATTR_CHANNEL) == (ICMP6_RPL << 8 | RPL_CODE_DAO)) {
if(!linkaddr_cmp(&fast_c_parent_linkaddr, &linkaddr_null)
&& linkaddr_cmp(&fast_c_parent_linkaddr, packetbuf_addr(PACKETBUF_ADDR_RECEIVER))) {
fast_c_parent_knows_us = 1;
}
}
}
/*---------------------------------------------------------------------------*/
static void
recv_runicast(struct runicast_conn *c, const linkaddr_t *from, uint8_t seqno)
{
/* OPTIONAL: Sender history */
struct history_entry *e = NULL;
for(e = list_head(history_table); e != NULL; e = e->next) {
if(linkaddr_cmp(&e->addr, from)) {
break;
}
}
if(e == NULL) {
/* Create new history entry */
e = memb_alloc(&history_mem);
if(e == NULL) {
e = list_chop(history_table); /* Remove oldest at full history */
}
linkaddr_copy(&e->addr, from);
e->seq = seqno;
list_push(history_table, e);
} else {
/* Detect duplicate callback */
if(e->seq == seqno) {
printf("runicast message received from %d.%d, seqno %d (DUPLICATE)\n",
from->u8[0], from->u8[1], seqno);
return;
}
/* Update existing history entry */
e->seq = seqno;
}
printf("runicast message received from %d.%d, seqno %d\n",
from->u8[0], from->u8[1], seqno);
}
/* Check if a packet is for us */
static int
is_packet_for_us(uint8_t *buf, int len, int do_send_ack)
{
frame802154_t frame;
int result;
uint8_t parsed = frame802154_parse(buf, len, &frame);
if(parsed) {
if(frame.fcf.dest_addr_mode) {
int has_dest_panid;
frame802154_has_panid(&frame.fcf, NULL, &has_dest_panid);
if(has_dest_panid
&& frame802154_get_pan_id() != FRAME802154_BROADCASTPANDID
&& frame.dest_pid != frame802154_get_pan_id()
&& frame.dest_pid != FRAME802154_BROADCASTPANDID) {
/* Packet to another PAN */
return 0;
}
if(!is_broadcast_addr(frame.fcf.dest_addr_mode, frame.dest_addr)) {
result = linkaddr_cmp((linkaddr_t *)frame.dest_addr, &linkaddr_node_addr);
if(autoack_enabled && result && do_send_ack) {
/* this is a unicast frame and sending ACKs is enabled */
send_ack(&frame);
}
return result;
}
}
return 1;
} else {
return 0;
}
}
/* Decrement backoff window for all queues directed at dest_addr */
void
tsch_queue_update_all_backoff_windows(const linkaddr_t *dest_addr)
{
if(!tsch_is_locked()) {
int is_broadcast = linkaddr_cmp(dest_addr, &tsch_broadcast_address);
struct tsch_neighbor *n = list_head(neighbor_list);
while(n != NULL) {
if(n->backoff_window != 0 /* Is the queue in backoff state? */
&& ((n->tx_links_count == 0 && is_broadcast)
|| (n->tx_links_count > 0 && linkaddr_cmp(dest_addr, &n->addr)))) {
n->backoff_window--;
}
n = list_item_next(n);
}
}
}
/*---------------------------------------------------------------------------*/
void
uip_ds6_link_neighbor_callback(int status, int numtx)
{
const linkaddr_t *dest = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
if(linkaddr_cmp(dest, &linkaddr_null)) {
return;
}
LINK_NEIGHBOR_CALLBACK(dest, status, numtx);
#if UIP_DS6_LL_NUD
if(status == MAC_TX_OK) {
uip_ds6_nbr_t *nbr;
nbr = uip_ds6_nbr_ll_lookup((uip_lladdr_t *)dest);
if(nbr != NULL &&
(nbr->state == NBR_STALE || nbr->state == NBR_DELAY ||
nbr->state == NBR_PROBE)) {
nbr->state = NBR_REACHABLE;
stimer_set(&nbr->reachable, UIP_ND6_REACHABLE_TIME / 1000);
PRINTF("uip-ds6-neighbor : received a link layer ACK : ");
PRINTLLADDR((uip_lladdr_t *)dest);
PRINTF(" is reachable.\n");
}
}
#endif /* UIP_DS6_LL_NUD */
}
uint8_t
wireless_output(const uip_lladdr_t * src, const uip_lladdr_t * dest)
{
int ret;
//Packet filtering
//----------------
if(uip_len == 0) {
LOG6LBR_ERROR("wireless_output: uip_len = 0\n");
return 0;
}
if(dest && linkaddr_cmp((linkaddr_t *) & dest,
(linkaddr_t *) & wsn_mac_addr)) {
LOG6LBR_ERROR("wireless_output: sending to self\n");
return 0;
}
//Packet sending
//--------------
if(wireless_outputfunc != NULL) {
LOG6LBR_PRINTF(PACKET, PF_OUT, "wireless_output: sending packet\n");
ret = wireless_outputfunc(dest);
} else {
ret = 0;
}
return ret;
}
/*---------------------------------------------------------------------------*/
static void packet_input(void)
{
if(packetbuf_datalen() == ACK_LEN){
/* Ignore ack packets */
PRINTF("nullrdc: ignored ack\n");
}else if(NETSTACK_FRAMER.parse() < 0){
PRINTF("nullrdc: failed to parse %u\n", packetbuf_datalen());
#if NULLRDC_ADDRESS_FILTER
}else if(!linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_node_addr) &&
!packetbuf_holds_broadcast()){
PRINTF("nullrdc: not for us\n");
#endif /* NULLRDC_ADDRESS_FILTER */
}else{
int duplicate = 0;
/* Check for duplicate packet. */
duplicate = mac_sequence_is_duplicate();
if(duplicate){
/* Drop the packet. */
PRINTF("nullrdc: drop duplicate link layer packet %u\n",
packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO));
}else{
mac_sequence_register_seqno();
}
if(!duplicate) {
NETSTACK_MAC.input();
}
}
}
int
cmd_handler_cooja(const uint8_t *data, int len)
{
if(data[0] == '!') {
if(data[1] == 'C' && len == 3) {
printf("cooja_cmd: setting channel: %d\n", data[2]);
radio_set_channel(data[2]);
//Enable radio
NETSTACK_RDC.off(1);
return 1;
} else if(data[1] == 'M' && len == 10) {
if(!linkaddr_cmp((linkaddr_t *)(data+2), &linkaddr_null)) {
printf("cooja_cmd: Got MAC\n");
if(linkaddr_cmp(&default_link_addr, &linkaddr_null)) {
linkaddr_copy(&default_link_addr, &linkaddr_node_addr);
}
memcpy(uip_lladdr.addr, data+2, sizeof(uip_lladdr.addr));
linkaddr_set_node_addr((linkaddr_t *) uip_lladdr.addr);
} else {
printf("cooja_cmd: Clear MAC disabled\n");
if(!linkaddr_cmp(&default_link_addr, &linkaddr_null)) {
memcpy(uip_lladdr.addr, &default_link_addr, sizeof(uip_lladdr.addr));
linkaddr_set_node_addr(&default_link_addr);
}
//Stop radio
NETSTACK_RDC.off(0);
}
return 1;
}
} else if(data[0] == '?') {
if(data[1] == 'C' && len == 2) {
uint8_t buf[4];
printf("cooja_cmd: getting channel: %d\n", data[2]);
buf[0] = '!';
buf[1] = 'C';
buf[2] = 0;
cmd_send(buf, 3);
return 1;
}
}
return 0;
}
uint8_t discovery_simple_is_neighbour(linkaddr_t * dest) {
struct discovery_neighbour_list_entry * entry;
for (entry = list_head(neighbour_list); entry != NULL ; entry = entry->next) {
if (linkaddr_cmp(&(entry->neighbour), dest)) {
return 1;
}
}
return 0;
}
/*---------------------------------------------------------------------------*/
static struct neighbor_queue *
neighbor_queue_from_addr(const linkaddr_t *addr)
{
struct neighbor_queue *n = list_head(neighbor_list);
while(n != NULL) {
if(linkaddr_cmp(&n->addr, addr)) {
return n;
}
n = list_item_next(n);
}
return NULL;
}
/*---------------------------------------------------------------------------*/
static void
rrep_packet_received(struct unicast_conn *uc, const linkaddr_t *from)
{
struct rrep_hdr *msg = packetbuf_dataptr();
struct route_entry *rt;
linkaddr_t dest;
struct route_discovery_conn *c = (struct route_discovery_conn *)
((char *)uc - offsetof(struct route_discovery_conn, rrepconn));
PRINTF("%d.%d: rrep_packet_received from %d.%d towards %d.%d len %d\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1],
from->u8[0],from->u8[1],
msg->dest.u8[0],msg->dest.u8[1],
packetbuf_datalen());
PRINTF("from %d.%d hops %d rssi %d lqi %d\n",
from->u8[0], from->u8[1],
msg->hops,
packetbuf_attr(PACKETBUF_ATTR_RSSI),
packetbuf_attr(PACKETBUF_ATTR_LINK_QUALITY));
insert_route(&msg->originator, from, msg->hops);
if(linkaddr_cmp(&msg->dest, &linkaddr_node_addr)) {
PRINTF("rrep for us!\n");
rrep_pending = 0;
ctimer_stop(&c->t);
if(c->cb->new_route) {
linkaddr_t originator;
/* If the callback modifies the packet, the originator address
will be lost. Therefore, we need to copy it into a local
variable before calling the callback. */
linkaddr_copy(&originator, &msg->originator);
c->cb->new_route(c, &originator);
}
} else {
linkaddr_copy(&dest, &msg->dest);
rt = route_lookup(&msg->dest);
if(rt != NULL) {
PRINTF("forwarding to %d.%d\n", rt->nexthop.u8[0], rt->nexthop.u8[1]);
msg->hops++;
unicast_send(&c->rrepconn, &rt->nexthop);
} else {
PRINTF("%d.%d: no route to %d.%d\n", linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1], msg->dest.u8[0], msg->dest.u8[1]);
}
}
}
void discovery_simple_dead(linkaddr_t * neighbour) {
struct discovery_neighbour_list_entry * entry;
LOG(LOGD_DTN, LOG_DISCOVERY, LOGL_INF, "Neighbor %u.%u disappeared", neighbour->u8[0], neighbour->u8[1]);
for (entry = list_head(neighbour_list); entry != NULL ; entry = entry->next) {
if (linkaddr_cmp(&(entry->neighbour), neighbour)) {
memb_free(&neighbour_mem, entry);
list_remove(neighbour_list, entry);
break;
}
}
}
uint8_t
switch_lookup_get_itf_for(const uip_lladdr_t *lladdr)
{
#if UIP_SWITCH_LOOKUP
if(lladdr != NULL && !linkaddr_cmp((linkaddr_t *)lladdr, &linkaddr_null)) {
uip_ds6_nbr_t *nbr;
nbr = uip_ds6_nbr_ll_lookup(lladdr);
if(nbr) {
return nbr->ifindex;
}
}
#endif
return NETWORK_ITF_UNKNOWN;
}
/* Get a TSCH neighbor */
struct tsch_neighbor *
tsch_queue_get_nbr(const linkaddr_t *addr)
{
if(!tsch_is_locked()) {
struct tsch_neighbor *n = list_head(neighbor_list);
while(n != NULL) {
if(linkaddr_cmp(&n->addr, addr)) {
return n;
}
n = list_item_next(n);
}
}
return NULL;
}
/*---------------------------------------------------------------------------*/
static uint8_t
input_packet(struct net_buf *buf)
{
frame802154_t frame;
int len;
len = packetbuf_datalen(buf);
PRINTF("6MAC: received %d bytes\n", len);
if(frame802154_parse(packetbuf_dataptr(buf), len, &frame) &&
packetbuf_hdrreduce(buf, len - frame.payload_len)) {
if(frame.fcf.dest_addr_mode) {
if(frame.dest_pid != mac_src_pan_id &&
frame.dest_pid != FRAME802154_BROADCASTPANDID) {
/* Not broadcast or for our PAN */
PRINTF("6MAC: for another pan %u (0x%x)\n", frame.dest_pid,
frame.dest_pid);
goto error;
}
if(!is_broadcast_addr(frame.fcf.dest_addr_mode, frame.dest_addr)) {
packetbuf_set_addr(buf, PACKETBUF_ADDR_RECEIVER, (linkaddr_t *)&frame.dest_addr);
#if !NETSTACK_CONF_BRIDGE_MODE
if(!linkaddr_cmp(packetbuf_addr(buf, PACKETBUF_ADDR_RECEIVER),
&linkaddr_node_addr)) {
/* Not for this node */
PRINTF("6MAC: not for us, we are ");
PRINTLLADDR((uip_lladdr_t *)&linkaddr_node_addr);
PRINTF(" recipient is ");
PRINTLLADDR((uip_lladdr_t *)packetbuf_addr(buf, PACKETBUF_ADDR_RECEIVER));
PRINTF("\n");
goto error;
}
#endif
}
}
packetbuf_set_addr(buf, PACKETBUF_ADDR_SENDER, (linkaddr_t *)&frame.src_addr);
PRINTF("6MAC-IN: type 0x%X sender ", frame.fcf.frame_type);
PRINTLLADDR((uip_lladdr_t *)packetbuf_addr(buf, PACKETBUF_ADDR_SENDER));
PRINTF(" receiver ");
PRINTLLADDR((uip_lladdr_t *)packetbuf_addr(buf, PACKETBUF_ADDR_RECEIVER));
PRINTF(" len %u\n", packetbuf_datalen(buf));
return NETSTACK_MAC.input(buf);
} else {
PRINTF("6MAC: failed to parse hdr\n");
}
error:
return 0;
}
static void
recv_runicast(struct runicast_conn *c, const linkaddr_t *from, uint8_t seqno)
{
struct history_entry *e = NULL;
int16_t data, id;
for(e = list_head(history_table); e != NULL; e = e->next)
{
if(linkaddr_cmp(&e->addr, from))
{
break;
}
}
if(e == NULL)
{
/* Create new history entry */
e = memb_alloc(&history_mem);
if(e == NULL)
{
e = list_chop(history_table); /* Remove oldest at full history */
}
linkaddr_copy(&e->addr, from);
e->seq = seqno;
list_push(history_table, e);
}
else
{
/* Detect duplicate callback */
if(e->seq == seqno)
{
printf("runicast message received from %d.%d, seqno %d (DUPLICATE)\n",
from->u8[0], from->u8[1], seqno);
}
/* Update existing history entry */
e->seq = seqno;
}
printf("Basestation: runicast message received from %d.%d, seqno %d\n",
from->u8[0], from->u8[1], seqno);
struct runicast_message *received_msg = packetbuf_dataptr();
if (received_msg->type == RUNICAST_TYPE_TEMP)
{
time_delay = received_msg->data;
printf("Temperature from actuator %d has value %d",id,data)
}
/*---------------------------------------------------------------------------*/
static void
recv_from_broadcast(struct broadcast_conn *broadcast, const linkaddr_t *from)
{
struct unicast_conn *c = (struct unicast_conn *)broadcast;
PRINTF("%d.%d: uc: recv_from_broadcast, receiver %d.%d\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]);
if(linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &linkaddr_node_addr)) {
if(c->u->recv) {
c->u->recv(c, from);
}
}
}
/*---------------------------------------------------------------------------*/
struct collect_neighbor *
collect_neighbor_list_find(struct collect_neighbor_list *neighbors_list,
const linkaddr_t *addr)
{
struct collect_neighbor *n;
if(neighbors_list == NULL) {
return NULL;
}
for(n = list_head(neighbors_list->list); n != NULL; n = list_item_next(n)) {
if(linkaddr_cmp(&n->addr, addr)) {
return n;
}
}
return NULL;
}
/*---------------------------------------------------------------------------*/
static void
packet_input(void)
{
int frame_parsed = 1;
frame_parsed = NETSTACK_FRAMER.parse();
if(frame_parsed < 0) {
PRINTF("TSCH:! failed to parse %u\n", packetbuf_datalen());
} else {
int duplicate = 0;
/* Seqno of 0xffff means no seqno */
if(packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO) != 0xffff) {
/* Check for duplicate packet by comparing the sequence number
of the incoming packet with the last few ones we saw. */
int i;
for(i = 0; i < MAX_SEQNOS; ++i) {
if(packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO) == received_seqnos[i].seqno &&
linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER),
&received_seqnos[i].sender)) {
/* Drop the packet. */
PRINTF("TSCH:! drop dup ll from %u seqno %u\n",
TSCH_LOG_ID_FROM_LINKADDR(packetbuf_addr(PACKETBUF_ADDR_SENDER)),
packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO));
duplicate = 1;
}
}
if(!duplicate) {
for(i = MAX_SEQNOS - 1; i > 0; --i) {
memcpy(&received_seqnos[i], &received_seqnos[i - 1],
sizeof(struct seqno));
}
received_seqnos[0].seqno = packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO);
linkaddr_copy(&received_seqnos[0].sender,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
}
}
if(!duplicate) {
PRINTF("TSCH: received from %u with seqno %u\n",
TSCH_LOG_ID_FROM_LINKADDR(packetbuf_addr(PACKETBUF_ADDR_SENDER)),
packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO));
NETSTACK_LLSEC.input();
}
}
}
void
switch_lookup_learn_addr(const uip_lladdr_t *lladdr, uint8_t ifindex)
{
#if UIP_SWITCH_LOOKUP
if(lladdr != NULL && !linkaddr_cmp((linkaddr_t *)lladdr, &linkaddr_null)) {
uip_ds6_nbr_t *nbr;
nbr = uip_ds6_nbr_ll_lookup(lladdr);
if(nbr) {
nbr->ifindex = ifindex;
} else {
LOG6LBR_LLADDR(PACKET, lladdr, "No neighbor found for ");
}
} else {
LOG6LBR_DEBUG("Can not learn broadcast or null addr\n");
}
#endif
}
uint8_t
wireless_output(const uip_lladdr_t * src, const uip_lladdr_t * dest)
{
int ret;
//Packet filtering
//----------------
if(uip_len == 0) {
LOG6LBR_ERROR("wireless_output: uip_len = 0\n");
return 0;
}
if(dest && linkaddr_cmp((linkaddr_t *) & dest,
(linkaddr_t *) & wsn_mac_addr)) {
LOG6LBR_ERROR("wireless_output: sending to self\n");
return 0;
}
#if CETIC_6LBR_WSN_FILTER_RA
//Filter out RA/RS towards WSN
if(UIP_IP_BUF->proto == UIP_PROTO_ICMP6 &&
(UIP_ICMP_BUF->type == ICMP6_RS || UIP_ICMP_BUF->type == ICMP6_RA)) {
return 0;
}
#endif
//Packet sending
//--------------
if(wireless_outputfunc != NULL) {
#if CETIC_6LBR_TRANSPARENTBRIDGE
if ( src != NULL ) {
platform_set_wsn_mac((linkaddr_t *)src);
}
#endif
LOG6LBR_PRINTF(PACKET, PF_OUT, "wireless_output: sending packet\n");
ret = wireless_outputfunc(dest);
#if CETIC_6LBR_TRANSPARENTBRIDGE
if ( src != NULL ) {
//Restore node address
platform_set_wsn_mac((linkaddr_t *) & wsn_mac_addr);
}
#endif
} else {
ret = 0;
}
return ret;
}
/*---------------------------------------------------------------------------*/
static int
select_packet(uint16_t *slotframe, uint16_t *timeslot)
{
/* Select data packets we have a unicast link to */
const linkaddr_t *dest = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
if(packetbuf_attr(PACKETBUF_ATTR_FRAME_TYPE) == FRAME802154_DATAFRAME
&& !linkaddr_cmp(dest, &linkaddr_null)) {
if(slotframe != NULL) {
*slotframe = slotframe_handle;
}
if(timeslot != NULL) {
*timeslot = get_node_timeslot(dest);
}
return 1;
}
return 0;
}
static int
eth_output(const uip_lladdr_t * src, const uip_lladdr_t * dest)
{
//Packet filtering
//----------------
if(uip_len == 0) {
LOG6LBR_ERROR("eth_output: uip_len = 0\n");
return 0;
}
if(dest && linkaddr_cmp((linkaddr_t *) & dest,
(linkaddr_t *) & eth_mac64_addr)) {
LOG6LBR_ERROR("ethernet_output: sending to self\n");
return 0;
}
//Create packet header
//--------------------
//Packet type
BUF->type = uip_htons(UIP_ETHTYPE_IPV6);
//Destination address
if(IS_BROADCAST_ADDR(dest)) {
BUF->dest.addr[0] = 0x33;
BUF->dest.addr[1] = 0x33;
BUF->dest.addr[2] = UIP_IP_BUF->destipaddr.u8[12];
BUF->dest.addr[3] = UIP_IP_BUF->destipaddr.u8[13];
BUF->dest.addr[4] = UIP_IP_BUF->destipaddr.u8[14];
BUF->dest.addr[5] = UIP_IP_BUF->destipaddr.u8[15];
} else {
memcpy(BUF->dest.addr, dest, 6);
}
//Source address
if ( src != NULL ) {
memcpy(BUF->src.addr, src, 6);
} else {
memcpy(BUF->src.addr, eth_mac_addr, 6);
}
//Sending packet
//--------------
LOG6LBR_PRINTF(PACKET, PF_OUT, "eth_output: Sending packet to Ethernet\n");
eth_drv_send();
return 1;
}
/* Get the index of a neighbor from its link-layer address */
static int
index_from_lladdr(const linkaddr_t *lladdr)
{
nbr_table_key_t *key;
/* Allow lladdr-free insertion, useful e.g. for IPv6 ND.
* Only one such entry is possible at a time, indexed by linkaddr_null. */
if(lladdr == NULL) {
lladdr = &linkaddr_null;
}
key = list_head(nbr_table_keys);
while(key != NULL) {
if(lladdr && linkaddr_cmp(lladdr, &key->lladdr)) {
return index_from_key(key);
}
key = list_item_next(key);
}
return -1;
}
static struct discovery_ipnd_neighbour_list_entry* discovery_ipnd_find_neighbour(const uint32_t eid)
{
if( discovery_status == 0 ) {
// Not initialized yet
return NULL;
}
const linkaddr_t addr = convert_eid_to_rime(eid);
for(struct discovery_ipnd_neighbour_list_entry* entry = list_head(neighbour_list);
entry != NULL;
entry = list_item_next(entry)) {
if( linkaddr_cmp(&entry->neighbour, &addr) ) {
return entry;
}
}
return NULL;
}
/**
* \brief Checks if ''neighbours'' is already known
* Yes: refresh timestamp
* No: Create entry
*
* \param neighbour Address of the neighbour that should be refreshed
* \return <0 error
* 0 neighbour not existing
* 1 neighbour was updated
*/
static int discovery_ipnd_refresh_neighbour(const cl_addr_t* const neighbour)
{
if (neighbour == NULL) {
LOG(LOGD_DTN, LOG_DISCOVERY, LOGL_WRN, "called with NULL pointer address.");
return -1;
}
#if DISCOVERY_IPND_WHITELIST > 0
int i;
int found = 0;
for(i=0; i<DISCOVERY_IPND_WHITELIST; i++) {
if( linkaddr_cmp(&discovery_whitelist[i], neighbour) ) {
found = 1;
break;
}
}
if( !found ) {
LOG(LOGD_DTN, LOG_DISCOVERY, LOGL_WRN, "Ignoring peer %u.%u, not on whitelist", neighbour->u8[0], neighbour->u8[1]);
return;
}
#endif
if( discovery_status == 0 ) {
// Not initialized yet
return - 2;
}
for(struct discovery_ipnd_neighbour_list_entry* entry = list_head(neighbour_list);
entry != NULL;
entry = list_item_next(entry)) {
if( discovery_neighbour_cmp( (struct discovery_neighbour_list_entry*)entry, neighbour ) ) {
if (neighbour->isIP) {
entry->timestamp_last_ip = clock_seconds();
} else {
entry->timestamp_last_lowpan = clock_seconds();
}
return 1;
}
}
return 0;
}
