/*---------------------------------------------------------------------------*/
static void
handle_beacon_send_timer(struct net_buf *buf, void *p)
{
struct net_buf *mbuf;
frame802154_t params;
uint8_t len;
mbuf = l2_buf_get_reserve(0);
if(!mbuf) {
return;
}
/* init to zeros */
memset(¶ms, 0, sizeof(params));
/* use packetbuf for sending ?? */
packetbuf_clear(mbuf);
/* Build the FCF. */
params.fcf.frame_type = FRAME802154_BEACONFRAME;
/* Insert IEEE 802.15.4 (2006) version bits. */
params.fcf.frame_version = FRAME802154_IEEE802154_2006;
/* assume long for now */
params.fcf.src_addr_mode = FRAME802154_LONGADDRMODE;
linkaddr_copy((linkaddr_t *)¶ms.src_addr, &linkaddr_node_addr);
/* Set the source PAN ID to the global variable. */
params.src_pid = panid;
params.fcf.dest_addr_mode = FRAME802154_SHORTADDRMODE;
params.dest_addr[0] = 0xFF;
params.dest_addr[1] = 0xFF;
params.dest_pid = 0xffff;
params.seq = framer_802154_next_seqno();
/* Calculate beacon length and copy it to packetbuf */
beacon_payload_len = handler_802154_calculate_beacon_payload_length(beacon_payload, BEACON_PAYLOAD_BUFFER_SIZE);
packetbuf_copyfrom(mbuf, beacon_payload, beacon_payload_len);
/* Set payload and payload length */
params.payload = packetbuf_dataptr(mbuf);
params.payload_len = packetbuf_datalen(mbuf);
len = frame802154_hdrlen(¶ms);
if(packetbuf_hdralloc(mbuf, len)) {
frame802154_create(¶ms, packetbuf_hdrptr(mbuf), len);
if(NETSTACK_RADIO.send(mbuf, packetbuf_hdrptr(mbuf),
packetbuf_totlen(mbuf)) != RADIO_TX_OK) {
l2_buf_unref(mbuf);
return;
}
HANDLER_802154_STAT(handler_802154_stats.beacons_sent++);
}
}
/*---------------------------------------------------------------------------*/
static int
output(struct channel *c)
{
const struct packetbuf_attrlist *a;
int byteptr, len;
uint8_t *hdrptr;
struct raw_hdr *hdr;
/* Compute the total size of the final header by summing the size of
all attributes that are used on this channel. */
if(packetbuf_hdralloc(c->hdrsize + sizeof(struct raw_hdr)) == 0) {
PRINTF("chameleon-raw: insufficient space for headers\n");
return 0;
}
hdr = (struct raw_hdr *)packetbuf_hdrptr();
hdr->channel[0] = c->channelno & 0xff;
hdr->channel[1] = (c->channelno >> 8) & 0xff;
hdrptr = ((uint8_t *)packetbuf_hdrptr()) + sizeof(struct raw_hdr);
byteptr = 0;
for(a = c->attrlist; a->type != PACKETBUF_ATTR_NONE; ++a) {
#if CHAMELEON_WITH_MAC_LINK_ADDRESSES
if(a->type == PACKETBUF_ADDR_SENDER ||
a->type == PACKETBUF_ADDR_RECEIVER) {
/* Let the link layer handle sender and receiver */
PRINTF("%d.%d: pack_header leaving sender/receiver to link layer\n");
continue;
}
#endif /* CHAMELEON_WITH_MAC_LINK_ADDRESSES */
PRINTF("%d.%d: pack_header type %d, len %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
a->type, a->len);
len = (a->len & 0xf8) + ((a->len & 7) ? 8: 0);
if(PACKETBUF_IS_ADDR(a->type)) {
const rimeaddr_t *rimeaddr;
/* memcpy(&hdrptr[byteptr], (uint8_t *)packetbuf_attr_aget(a->type), len / 8);*/
rimeaddr = packetbuf_addr(a->type);
hdrptr[byteptr] = rimeaddr->u8[0];
hdrptr[byteptr + 1] = rimeaddr->u8[1];
PRINTF("%d.%d: address %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
((uint8_t *)packetbuf_addr(a->type))[0],
((uint8_t *)packetbuf_addr(a->type))[1]);
} else {
packetbuf_attr_t val;
val = packetbuf_attr(a->type);
memcpy(&hdrptr[byteptr], &val, len / 8);
PRINTF("%d.%d: value %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
val);
}
byteptr += len / 8;
}
return 1; /* Send out packet */
}
/*---------------------------------------------------------------------------*/
static void
packet_input(void)
{
#if NETSTACK_CONF_WITH_IP64
/* If NAT64 is enabled, IPv4 & ARP packets are sent to the IP64 module */
ethernet_header_t *hdr = (ethernet_header_t *)packetbuf_hdrptr();
if (hdr->et_protlen == UIP_HTONS(ETH_PROT_IP) ||
hdr->et_protlen == UIP_HTONS(ETH_PROT_ARP)) {
IP64_INPUT(packetbuf_hdrptr(), packetbuf_totlen());
return;
}
#endif /* NETSTACK_CONF_WITH_IP64 */
if(NETSTACK_0_FRAMER.parse() < 0) {
PRINTF("ieee8023_mac: failed to parse %u\n", (unsigned int)packetbuf_datalen());
#if IEEE8023_MAC_ADDRESS_FILTER
} else if(!linkaddr6_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr6_node_addr) &&
!linkaddr6_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr6_null)) {
/*\note The framer should have done the multicast address
* translation from 0x33 0x33 0xXX... to the 802.3xx null
*/
PRINTF("ieee8023_mac: not for us\n");
#endif /* IEEE8023_MAC_ADDRESS_FILTER */
} else {
int duplicate = 0;
duplicate = mac_sequence_is_duplicate();
if(duplicate && ETH_SUPPORT_DUPLICATE_DETECTION) {
/* Drop the packet. */
PRINTF("ieee8023_mac: drop duplicate link layer packet %u\n",
packetbuf_attr(PACKETBUF_ATTR_PACKET_ID));
} else {
mac_sequence_register_seqno();
}
#if DEBUG
int i;
uint16_t original_datalen = packetbuf_totlen();
uint8_t *original_dataptr = packetbuf_hdrptr();
PRINTF("PKT[%u]:",original_datalen);
for (i=0; i<original_datalen; i++) {
PRINTF("%02x ",original_dataptr[i]);
}
PRINTF("\n");
#endif
if(!(duplicate && ETH_SUPPORT_DUPLICATE_DETECTION)) {
link_if_in(NETSTACK_8023);
NETSTACK_0_NETWORK.input();
link_if_in(NETSTACK_NULL);
} else {
PRINTF("IEEE8023_MAC: drop duplicate\n");
}
}
}
/* called to send a beacon request */
void
handler_802154_send_beacon_request(void)
{
struct net_buf *mbuf;
frame802154_t params;
uint8_t len;
mbuf = l2_buf_get_reserve(0);
if(!mbuf) {
return;
}
/* init to zeros */
memset(¶ms, 0, sizeof(params));
/* use packetbuf for sending ?? */
packetbuf_clear(mbuf);
/* Build the FCF. */
params.fcf.frame_type = FRAME802154_CMDFRAME;
/* Insert IEEE 802.15.4 (2006) version bits. */
params.fcf.frame_version = FRAME802154_IEEE802154_2006;
params.fcf.src_addr_mode = FRAME802154_NOADDR;
params.fcf.dest_addr_mode = FRAME802154_SHORTADDRMODE;
params.dest_addr[0] = 0xFF;
params.dest_addr[1] = 0xFF;
params.dest_pid = 0xffff;
params.seq = chseqno;
packetbuf_set_datalen(mbuf, 1);
params.payload = packetbuf_dataptr(mbuf);
/* set the type in the payload */
params.payload[0] = FRAME802154_BEACONREQ;
params.payload_len = packetbuf_datalen(mbuf);
len = frame802154_hdrlen(¶ms);
if(packetbuf_hdralloc(mbuf, len)) {
frame802154_create(¶ms, packetbuf_hdrptr(mbuf), len);
if(NETSTACK_RADIO.send(mbuf, packetbuf_hdrptr(mbuf),
packetbuf_totlen(mbuf)) != RADIO_TX_OK) {
l2_buf_unref(mbuf);
return;
}
HANDLER_802154_STAT(handler_802154_stats.beacons_reqs_sent++);
}
}
/*---------------------------------------------------------------------------*/
static int
output(struct channel *c)
{
const struct packetbuf_attrlist *a;
int byteptr, len;
uint8_t *hdrptr;
struct raw_hdr *hdr;
/* Compute the total size of the final header by summing the size of
all attributes that are used on this channel. */
packetbuf_hdralloc(c->hdrsize);
hdrptr = packetbuf_hdrptr();
byteptr = 0;
for(a = c->attrlist; a->type != PACKETBUF_ATTR_NONE; ++a) {
PRINTF("%d.%d: pack_header type %s, len %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
packetbuf_attr_strings[a->type], a->len);
len = (a->len & 0xf8) + ((a->len & 7) ? 8: 0);
if(a->type == PACKETBUF_ADDR_SENDER ||
a->type == PACKETBUF_ADDR_RECEIVER ||
a->type == PACKETBUF_ADDR_ESENDER ||
a->type == PACKETBUF_ADDR_ERECEIVER) {
const rimeaddr_t *rimeaddr;
/* memcpy(&hdrptr[byteptr], (uint8_t *)packetbuf_attr_aget(a->type), len / 8);*/
rimeaddr = packetbuf_addr(a->type);
hdrptr[byteptr] = rimeaddr->u8[0];
hdrptr[byteptr + 1] = rimeaddr->u8[1];
PRINTF("%d.%d: address %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
((uint8_t *)packetbuf_addr(a->type))[0],
((uint8_t *)packetbuf_addr(a->type))[1]);
} else {
packetbuf_attr_t val;
val = packetbuf_attr(a->type);
memcpy(&hdrptr[byteptr], &val, len / 8);
PRINTF("%d.%d: value %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
val);
}
byteptr += len / 8;
}
packetbuf_hdralloc(sizeof(struct raw_hdr));
hdr = (struct raw_hdr *)packetbuf_hdrptr();
hdr->channel = c->channelno;
return 1; /* Send out packet */
}
PROCESS_THREAD(rime_udp_process, ev, data)
{
static uip_ipaddr_t ipaddr;
PROCESS_BEGIN();
broadcast_conn = udp_broadcast_new(HTONS(RIME_UDP_PORT), NULL);
if(broadcast_conn == NULL) {
PRINTF("rime-udp: Failed to allocate a broadcast connection!\n");
}
uip_create_unspecified(&ipaddr);
unicast_conn = udp_new(&ipaddr, HTONS(RIME_UDP_PORT), NULL);
if(unicast_conn == NULL) {
PRINTF("rime-udp: Failed to allocate a unicast connection!\n");
}
udp_bind(unicast_conn, HTONS(RIME_UDP_PORT));
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
if(uip_newdata()) {
packetbuf_clear();
memmove(packetbuf_hdrptr(), uip_appdata, uip_datalen());
PRINTF("rime-udp: received %d bytes\n", uip_datalen());
receiver_callback(&rime_udp_driver);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
void
adaptivesec_aead(uint8_t *key, int shall_encrypt, uint8_t *result, int forward)
{
uint8_t nonce[CCM_STAR_NONCE_LENGTH];
uint8_t *m;
uint8_t m_len;
uint8_t *a;
uint8_t a_len;
ccm_star_packetbuf_set_nonce(nonce, forward);
a = packetbuf_hdrptr();
if(shall_encrypt) {
#if AKES_NBR_WITH_GROUP_KEYS && PACKETBUF_WITH_UNENCRYPTED_BYTES
a_len = packetbuf_hdrlen() + packetbuf_attr(PACKETBUF_ATTR_UNENCRYPTED_BYTES);
#else /* AKES_NBR_WITH_GROUP_KEYS && PACKETBUF_WITH_UNENCRYPTED_BYTES */
a_len = packetbuf_hdrlen();
#endif /* AKES_NBR_WITH_GROUP_KEYS && PACKETBUF_WITH_UNENCRYPTED_BYTES */
m = a + a_len;
m_len = packetbuf_totlen() - a_len;
} else {
a_len = packetbuf_totlen();
m = NULL;
m_len = 0;
}
AES_128_GET_LOCK();
ADAPTIVESEC_SET_KEY(key);
CCM_STAR.aead(nonce,
m, m_len,
a, a_len,
result, adaptivesec_mic_len(),
forward);
AES_128_RELEASE_LOCK();
}
/*---------------------------------------------------------------------------*/
int
rmh_send(struct rmh_conn *c, rimeaddr_t *to, uint8_t num_rexmit, uint8_t max_hops)
{
rimeaddr_t *nexthop;
struct data_hdr *hdr;
c->num_rexmit = num_rexmit;
if(c->cb->forward == NULL) {
return 0;
}
nexthop = c->cb->forward(c, &rimeaddr_node_addr, to, NULL, 0);
if(nexthop == NULL) {
PRINTF("rmh_send: no route\n");
return 0;
} else {
PRINTF("rmh_send: sending data\n");
if(packetbuf_hdralloc(sizeof(struct data_hdr))) {
hdr = packetbuf_hdrptr();
rimeaddr_copy(&hdr->dest, to);
rimeaddr_copy(&hdr->originator, &rimeaddr_node_addr);
hdr->hops = 1;
hdr->max_rexmits = num_rexmit;
runicast_send(&c->c, nexthop, num_rexmit);
}
return 1;
}
}
/* -------------------------------------------------------------------- */
static void input_packet(void)
{
static struct packet_s reference_packet;
static uint16_t last_number;
static uint16_t rx_ok;
static uint16_t rx_corrupt;
struct packet_s *p = (struct packet_s *) packetbuf_hdrptr();
if(memcmp(p->filling, reference_packet.filling, sizeof(p->filling))) {
/* corrupt packet detected */
rx_corrupt++;
return;
}
if(last_number > p->number) {
printf("Out of 100 packets %u seen, %u good, %u corrupt\n",
rx_ok + rx_corrupt + (uint16_t)rimestats.badcrc,
rx_ok, rx_corrupt + (uint16_t)rimestats.badcrc);
rx_ok = 0;
rx_corrupt = 0;
rimestats.badcrc = 0;
}
rx_ok++;
last_number = p->number;
}
static void
send_announcement(void *ptr)
{
struct xmac_hdr *hdr;
int announcement_len;
/* Set up the probe header. */
packetbuf_clear();
hdr = packetbuf_dataptr();
announcement_len = format_announcement((char *)hdr +
sizeof(struct xmac_hdr));
if(announcement_len > 0) {
packetbuf_set_datalen(sizeof(struct xmac_hdr) + announcement_len);
hdr->dispatch = DISPATCH;
hdr->type = TYPE_ANNOUNCEMENT;
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &rimeaddr_null);
packetbuf_set_attr(PACKETBUF_ATTR_RADIO_TXPOWER, announcement_radio_txpower);
if(NETSTACK_FRAMER.create() >= 0) {
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
}
}
}
/*---------------------------------------------------------------------------*/
static int
send_packet(void)
{
if(radio->send(packetbuf_hdrptr(), packetbuf_totlen()) == RADIO_TX_OK) {
return MAC_TX_OK;
}
return MAC_TX_ERR;
}
/*---------------------------------------------------------------------------*/
int
packetbuf_copyto(void *to)
{
if(packetbuf->hdrlen + packetbuf->datalen > PACKETBUF_SIZE) {
return 0;
}
memcpy(to, packetbuf_hdrptr(), packetbuf->hdrlen);
memcpy((uint8_t *)to + packetbuf->hdrlen, packetbuf_dataptr(), packetbuf->datalen);
return packetbuf->hdrlen + packetbuf->datalen;
}
/*---------------------------------------------------------------------------*/
int
packetbuf_copyto(void *to)
{
if(hdrlen + buflen > PACKETBUF_SIZE) {
return 0;
}
memcpy(to, packetbuf_hdrptr(), hdrlen);
memcpy((uint8_t *)to + hdrlen, packetbuf_dataptr(), buflen);
return hdrlen + buflen;
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
int ret;
if(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()) == RADIO_TX_OK) {
ret = MAC_TX_OK;
} else {
ret = MAC_TX_ERR;
}
mac_call_sent_callback(sent, ptr, ret, 1);
}
/*---------------------------------------------------------------------------*/
static int
send_packet(void)
{
const rimeaddr_t *addr;
addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
PRINTF("rime-udp: Sending %d bytes to %d.%d\n", packetbuf_totlen(),
addr->u8[RIMEADDR_SIZE-2], addr->u8[RIMEADDR_SIZE-1]);
if(rimeaddr_cmp(&rimeaddr_null, addr)) {
uip_udp_packet_send(broadcast_conn,
packetbuf_hdrptr(), packetbuf_totlen());
} else {
uip_ip6addr(&unicast_conn->ripaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0);
uip_netif_addr_autoconf_set(&unicast_conn->ripaddr, (uip_lladdr_t *)addr);
uip_udp_packet_send(unicast_conn,
packetbuf_hdrptr(), packetbuf_totlen());
uip_create_unspecified(&unicast_conn->ripaddr);
}
return 1;
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent_callback, void *ptr)
{
const rimeaddr_t *addr;
addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
PRINTF("rime-udp: Sending %d bytes to %d.%d\n", packetbuf_totlen(),
addr->u8[0], addr->u8[1]);
if(rimeaddr_cmp(&rimeaddr_null, addr)) {
uip_udp_packet_send(broadcast_conn,
packetbuf_hdrptr(), packetbuf_totlen());
mac_call_sent_callback(sent_callback, ptr, MAC_TX_OK, 1);
} else {
uip_ip6addr(&unicast_conn->ripaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0);
uip_netif_addr_autoconf_set(&unicast_conn->ripaddr, (uip_lladdr_t *)addr);
uip_udp_packet_send(unicast_conn,
packetbuf_hdrptr(), packetbuf_totlen());
uip_create_unspecified(&unicast_conn->ripaddr);
}
return;
}
/**
* Send a probe packet.
*/
static void
send_probe(void)
{
struct lpp_hdr *hdr;
struct announcement_msg *adata;
struct announcement *a;
/* Set up the probe header. */
packetbuf_clear();
packetbuf_set_datalen(sizeof(struct lpp_hdr));
hdr = packetbuf_dataptr();
hdr->type = TYPE_PROBE;
rimeaddr_copy(&hdr->sender, &rimeaddr_node_addr);
/* rimeaddr_copy(&hdr->receiver, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));*/
rimeaddr_copy(&hdr->receiver, &rimeaddr_null);
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &rimeaddr_null);
{
int hdrlen = NETSTACK_FRAMER.create();
if(hdrlen == 0) {
/* Failed to send */
return;
}
}
/* Construct the announcements */
adata = (struct announcement_msg *)((char *)hdr + sizeof(struct lpp_hdr));
adata->num = 0;
for(a = announcement_list(); a != NULL; a = list_item_next(a)) {
adata->data[adata->num].id = a->id;
adata->data[adata->num].value = a->value;
adata->num++;
}
packetbuf_set_datalen(sizeof(struct lpp_hdr) +
ANNOUNCEMENT_MSG_HEADERLEN +
sizeof(struct announcement_data) * adata->num);
/* PRINTF("Sending probe\n");*/
/* printf("probe\n");*/
if(NETSTACK_RADIO.channel_clear()) {
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
} else {
off_time_adjustment = random_rand() % (OFF_TIME / 2);
}
compower_accumulate(&compower_idle_activity);
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
int size;
/* 3 bytes per packet attribute is required for serialization */
uint8_t buf[PACKETBUF_NUM_ATTRS * 3 + PACKETBUF_SIZE + 3];
int sid;
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &linkaddr_node_addr);
/* ack or not ? */
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
if(NETSTACK_FRAMER.create_and_secure() < 0) {
/* Failed to allocate space for headers */
LOG6LBR_ERROR("br-rdc: send failed, too large header\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1);
} else {
/* here we send the data over SLIP to the radio-chip */
size = 0;
if(sixlbr_config_slip_serialize_tx_attrs) {
size = packetutils_serialize_atts(&buf[3], sizeof(buf) - 3);
}
if(size < 0 || size + packetbuf_totlen() + 3 > sizeof(buf)) {
LOG6LBR_ERROR("br-rdc: send failed, too large header\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1);
} else {
sid = setup_callback(sent, ptr);
if (sid != -1) {
LOG6LBR_PRINTF(PACKET, RADIO_OUT, "write: %d (sid: %d, cb: %d)\n", packetbuf_datalen(), sid, callback_count);
LOG6LBR_DUMP_PACKET(RADIO_OUT, packetbuf_dataptr(), packetbuf_datalen());
buf[0] = '!';
buf[1] = 'S';
buf[2] = sid; /* sequence or session number for this packet */
/* Copy packet data */
memcpy(&buf[3 + size], packetbuf_hdrptr(), packetbuf_totlen());
callbacks[sid].buf_len = packetbuf_totlen() + size + 3;
memcpy(callbacks[sid].buf, buf, callbacks[sid].buf_len);
write_to_slip(buf, callbacks[sid].buf_len);
} else {
LOG6LBR_INFO("native-rdc queue full\n");
mac_call_sent_callback(sent, ptr, MAC_TX_NOACK, 1);
}
}
}
}
/*---------------------------------------------------------------------------*/
static int
create(void)
{
struct nullmac_hdr *hdr;
if(packetbuf_hdralloc(sizeof(struct nullmac_hdr))) {
hdr = packetbuf_hdrptr();
linkaddr_copy(&(hdr->sender), &linkaddr_node_addr);
linkaddr_copy(&(hdr->receiver), packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
return sizeof(struct nullmac_hdr);
}
PRINTF("PNULLMAC-UT: too large header: %u\n", sizeof(struct nullmac_hdr));
return FRAMER_FAILED;
}
/*---------------------------------------------------------------------------*/
static void
send_nack(struct rudolph0_conn *c)
{
struct rudolph0_hdr *hdr;
packetbuf_clear();
packetbuf_hdralloc(sizeof(struct rudolph0_hdr));
hdr = packetbuf_hdrptr();
hdr->type = TYPE_NACK;
hdr->version = c->current.h.version;
hdr->chunk = c->current.h.chunk;
PRINTF("Sending nack for %d:%d\n", hdr->version, hdr->chunk);
polite_send(&c->nackc, c->send_interval / 2, sizeof(struct rudolph0_hdr));
}
/*---------------------------------------------------------------------------*/
static char
plb_send_strobe(rimeaddr_t *dst, int *acked, uint8_t type)
{
PRINTF("plb_send_strobe [dst: %u.%u] [type: %x]\n",dst->u8[0],dst->u8[1],type);
uint8_t strobe[MAX_STROBE_SIZE];
int strobe_len = 0;
rtimer_clock_t wt;
// Make PLB header
packetbuf_clear();
if( (strobe_len = plb_create_header(dst,type)) < 0 ){
return -1;
}
// Make packet -> strobe
strobe_len = strobe_len +1; // assign space for packet type
if( strobe_len > (int)sizeof(strobe)) {
/* Failed to send */
PRINTF("plb: send failed, too large header\n");
return -1;
}
memcpy(strobe, packetbuf_hdrptr(), strobe_len);
/* Send beacon and wait ack : STROBE_NUM_MAX times */
int strobe_num = 0;
radio_on();
while((strobe_num < STROBE_NUM_MAX) && ((*acked) == 0)){
PRINTF("plb_send_strobe : strobe %d\n",strobe_num);
#if DEBUG_PACKET
print_packet(strobe, strobe_len);
#endif
if(NETSTACK_RADIO.send(strobe, strobe_len) != RADIO_TX_OK){
return -1;
}
strobe_num ++;
(*acked) = plb_wait_ack(type);
if(*acked){
PRINTF("ack! return: %d\n", *acked);
}
}
radio_off();
return 0;
}
/*---------------------------------------------------------------------------*/
void
queuebuf_to_packetbuf(struct queuebuf *b)
{
struct queuebuf_ref *r;
if(memb_inmemb(&bufmem, b)) {
struct queuebuf_data *buframptr = queuebuf_load_to_ram(b);
packetbuf_copyfrom(buframptr->data, buframptr->len);
packetbuf_attr_copyfrom(buframptr->attrs, buframptr->addrs);
} else if(memb_inmemb(&refbufmem, b)) {
r = (struct queuebuf_ref *)b;
packetbuf_clear();
packetbuf_copyfrom(r->ref, r->len);
packetbuf_hdralloc(r->hdrlen);
memcpy(packetbuf_hdrptr(), r->hdr, r->hdrlen);
}
}
/*---------------------------------------------------------------------------*/
int
netflood_send(struct netflood_conn *c, uint8_t seqno)
{
if(packetbuf_hdralloc(sizeof(struct netflood_hdr))) {
struct netflood_hdr *hdr = packetbuf_hdrptr();
rimeaddr_copy(&hdr->originator, &rimeaddr_node_addr);
rimeaddr_copy(&c->last_originator, &hdr->originator);
c->last_originator_seqno = hdr->originator_seqno = seqno;
hdr->hops = 0;
PRINTF("%d.%d: netflood sending '%s'\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
(char *)packetbuf_dataptr());
return ipolite_send(&c->c, 0, 4);
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void
send_nack(struct rudolph1mh_conn *c)
{
struct rudolph1mh_hdr *hdr;
packetbuf_clear();
packetbuf_hdralloc(sizeof(struct rudolph1mh_hdr));
hdr = packetbuf_hdrptr();
hdr->type = TYPE_NACK;
hdr->s_id = c->s_id;
hdr->chunk = c->chunk;
PRINTF("%d.%d: Sending nack for %d:%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr->s_id, hdr->chunk);
mesh_send(&c->mesh, &c->partner);
}
/*---------------------------------------------------------------------------*/
static void
send_busy(struct rudolph1mh_conn *c, rimeaddr_t * to)
{
struct rudolph1mh_hdr *hdr;
packetbuf_clear();
packetbuf_hdralloc(sizeof(struct rudolph1mh_hdr));
hdr = packetbuf_hdrptr();
hdr->type = TYPE_BUSY;
hdr->s_id = 0;
hdr->chunk = 0;
PRINTF("%d.%d: Sending nack for %d:%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr->s_id, hdr->chunk);
mesh_send(&c->mesh, to);
}
/*---------------------------------------------------------------------------*/
static void
send_nack(struct rudolph1_conn *c)
{
struct rudolph1_hdr *hdr;
packetbuf_clear();
packetbuf_hdralloc(sizeof(struct rudolph1_hdr));
hdr = packetbuf_hdrptr();
hdr->type = TYPE_NACK;
hdr->version = c->version;
hdr->chunk = c->chunk;
PRINTF("%d.%d: Sending nack for %d:%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr->version, hdr->chunk);
ipolite_send(&c->ipolite, NACK_TIMEOUT, sizeof(struct rudolph1_hdr));
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
int ret;
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
if(NETSTACK_FRAMER.create() == 0) {
/* Failed to allocate space for headers */
PRINTF("nullrdc_framer: send failed, too large header\n");
ret = MAC_TX_ERR_FATAL;
} else if(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen())
== RADIO_TX_OK) {
ret = MAC_TX_OK;
} else {
ret = MAC_TX_ERR;
}
mac_call_sent_callback(sent, ptr, ret, 1);
}
/*---------------------------------------------------------------------------*/
static void
send_ack(struct rudolph1mh_conn *c)
{
struct rudolph1mh_hdr *hdr;
packetbuf_clear();
packetbuf_hdralloc(sizeof(struct rudolph1mh_hdr));
hdr = packetbuf_hdrptr();
hdr->type = TYPE_ACK;
hdr->s_id = c->s_id;
hdr->chunk = c->highest_chunk; //The highest chunk received
PRINTF("%d.%d: Sending ack for %d:%d to %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr->s_id, hdr->chunk, c->partner.u8[0], c->partner.u8[1]);
mesh_send(&c->mesh, &c->partner);
}
/*---------------------------------------------------------------------------*/
static void
send_nack(struct rudolph2_conn *c)
{
struct rudolph2_hdr *hdr;
packetbuf_clear();
packetbuf_hdralloc(sizeof(struct rudolph2_hdr));
hdr = packetbuf_hdrptr();
hdr->hops_from_base = c->hops_from_base;
hdr->type = TYPE_NACK;
hdr->version = c->version;
hdr->chunk = c->rcv_nxt;
PRINTF("%d.%d: Sending nack for %d\n",
rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1],
hdr->chunk);
polite_send(&c->c, NACK_TIMEOUT, POLITE_HEADER);
}
/*---------------------------------------------------------------------------*/
static void
plb_send_ack(uint8_t type){
uint8_t ack[MAX_ACK_SIZE];
int ack_len = 0;
//set address from input packet
addr_ack.u8[0]=packetbuf_addr(PACKETBUF_ADDR_SENDER)->u8[0];
addr_ack.u8[1]=packetbuf_addr(PACKETBUF_ADDR_SENDER)->u8[1];
PRINTF("plb_send_ack [dst: %u.%u] [type: %x]\n", addr_ack.u8[0], addr_ack.u8[1], type);
packetbuf_clear();
if ((ack_len = plb_create_header(&addr_ack, type)) < 0) {
PRINTF("ERROR: plb_create_header ");
return;
}
ack_len++;
//Make ack frame//
if (ack_len > (int) sizeof(ack)) {
// Failed to send //
PRINTF("plb: send failed, too large header\n");
return;
}
memcpy(ack, packetbuf_hdrptr(), ack_len);
// Send beacon and wait ack : STROBE_NUM_MAX times //
radio_on();
#if DEBUG_PACKET
print_packet(ack, ack_len);
#endif
if (NETSTACK_RADIO.send(ack, ack_len) != RADIO_TX_OK) {
PRINTF("ERROR: plb ack send");
return;
}
radio_off();
return;
}
