9e216da9ef
After go1.16, go will use module mode by default, even when the repository is checked out under GOPATH or in a one-off directory. Add go.mod, go.sum to keep this repo buildable without opting out of the module mode. > go mod init github.com/mmcgrana/gobyexample > go mod tidy > go mod vendor In module mode, the 'vendor' directory is special and its contents will be actively maintained by the go command. pygments aren't the dependency the go will know about, so it will delete the contents from vendor directory. Move it to `third_party` directory now. And, vendor the blackfriday package. Note: the tutorial contents are not affected by the change in go1.16 because all the examples in this tutorial ask users to run the go command with the explicit list of files to be compiled (e.g. `go run hello-world.go` or `go build command-line-arguments.go`). When the source list is provided, the go command does not have to compute the build list and whether it's running in GOPATH mode or module mode becomes irrelevant.
672 lines
20 KiB
Plaintext
672 lines
20 KiB
Plaintext
/*
|
|
* "Copyright (c) 2008 The Regents of the University of California.
|
|
* All rights reserved."
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software and its
|
|
* documentation for any purpose, without fee, and without written agreement is
|
|
* hereby granted, provided that the above copyright notice, the following
|
|
* two paragraphs and the author appear in all copies of this software.
|
|
*
|
|
* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
|
|
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
|
|
* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
|
|
* CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
|
|
* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
|
|
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
|
|
*
|
|
*/
|
|
|
|
#include <lib6lowpan/blip-tinyos-includes.h>
|
|
#include <lib6lowpan/6lowpan.h>
|
|
#include <lib6lowpan/lib6lowpan.h>
|
|
#include <lib6lowpan/ip.h>
|
|
#include <lib6lowpan/in_cksum.h>
|
|
#include <lib6lowpan/ip_malloc.h>
|
|
|
|
#include "blip_printf.h"
|
|
#include "IPDispatch.h"
|
|
#include "BlipStatistics.h"
|
|
#include "table.h"
|
|
|
|
/*
|
|
* Provides IP layer reception to applications on motes.
|
|
*
|
|
* @author Stephen Dawson-Haggerty <stevedh@cs.berkeley.edu>
|
|
*/
|
|
|
|
module IPDispatchP {
|
|
provides {
|
|
interface SplitControl;
|
|
// interface for protocols not requiring special hand-holding
|
|
interface IPLower;
|
|
|
|
interface BlipStatistics<ip_statistics_t>;
|
|
|
|
}
|
|
uses {
|
|
interface Boot;
|
|
|
|
|
|
/* link-layer wiring */
|
|
interface SplitControl as RadioControl;
|
|
|
|
interface Packet as BarePacket;
|
|
interface Send as Ieee154Send;
|
|
interface Receive as Ieee154Receive;
|
|
|
|
/* context lookup */
|
|
interface NeighborDiscovery;
|
|
|
|
interface ReadLqi;
|
|
interface PacketLink;
|
|
interface LowPowerListening;
|
|
|
|
/* buffers for outgoing fragments */
|
|
interface Pool<message_t> as FragPool;
|
|
interface Pool<struct send_info> as SendInfoPool;
|
|
interface Pool<struct send_entry> as SendEntryPool;
|
|
interface Queue<struct send_entry *> as SendQueue;
|
|
|
|
/* expire reconstruction */
|
|
interface Timer<TMilli> as ExpireTimer;
|
|
|
|
interface Leds;
|
|
|
|
}
|
|
provides interface Init;
|
|
} implementation {
|
|
|
|
#define HAVE_LOWPAN_EXTERN_MATCH_CONTEXT
|
|
int lowpan_extern_read_context(struct in6_addr *addr, int context) {
|
|
return call NeighborDiscovery.getContext(context, addr);
|
|
}
|
|
|
|
int lowpan_extern_match_context(struct in6_addr *addr, uint8_t *ctx_id) {
|
|
return call NeighborDiscovery.matchContext(addr, ctx_id);
|
|
}
|
|
|
|
// generally including source files like this is a no-no. I'm doing
|
|
// this in the hope that the optimizer will do a better job when
|
|
// they're part of a component.
|
|
#include <lib6lowpan/ieee154_header.c>
|
|
#include <lib6lowpan/lib6lowpan.c>
|
|
#include <lib6lowpan/lib6lowpan_4944.c>
|
|
#include <lib6lowpan/lib6lowpan_frag.c>
|
|
|
|
enum {
|
|
S_RUNNING,
|
|
S_STOPPED,
|
|
S_STOPPING,
|
|
};
|
|
uint8_t state = S_STOPPED;
|
|
bool radioBusy;
|
|
uint8_t current_local_label = 0;
|
|
ip_statistics_t stats;
|
|
|
|
// this in theory could be arbitrarily large; however, it needs to
|
|
// be large enough to hold all active reconstructions, and any tags
|
|
// which we are dropping. It's important to keep dropped tags
|
|
// around for a while, or else there are pathological situations
|
|
// where you continually allocate buffers for packets which will
|
|
// never complete.
|
|
|
|
////////////////////////////////////////
|
|
//
|
|
//
|
|
|
|
table_t recon_cache;
|
|
|
|
// table of packets we are currently receiving fragments from, that
|
|
// are destined to us
|
|
struct lowpan_reconstruct recon_data[N_RECONSTRUCTIONS];
|
|
|
|
//
|
|
//
|
|
////////////////////////////////////////
|
|
|
|
// task void sendTask();
|
|
|
|
void reconstruct_clear(void *ent) {
|
|
struct lowpan_reconstruct *recon = (struct lowpan_reconstruct *)ent;
|
|
memclr((uint8_t *)&recon->r_meta, sizeof(struct ip6_metadata));
|
|
recon->r_timeout = T_UNUSED;
|
|
recon->r_buf = NULL;
|
|
}
|
|
|
|
struct send_info *getSendInfo() {
|
|
struct send_info *ret = call SendInfoPool.get();
|
|
if (ret == NULL) return ret;
|
|
ret->_refcount = 1;
|
|
ret->upper_data = NULL;
|
|
ret->failed = FALSE;
|
|
ret->link_transmissions = 0;
|
|
ret->link_fragments = 0;
|
|
ret->link_fragment_attempts = 0;
|
|
return ret;
|
|
}
|
|
#define SENDINFO_INCR(X) ((X)->_refcount)++
|
|
void SENDINFO_DECR(struct send_info *si) {
|
|
if (--(si->_refcount) == 0) {
|
|
call SendInfoPool.put(si);
|
|
}
|
|
}
|
|
|
|
command error_t SplitControl.start() {
|
|
return call RadioControl.start();
|
|
}
|
|
|
|
command error_t SplitControl.stop() {
|
|
if (!radioBusy) {
|
|
state = S_STOPPED;
|
|
return call RadioControl.stop();
|
|
} else {
|
|
// if there's a packet in the radio, wait for it to exit before
|
|
// stopping
|
|
state = S_STOPPING;
|
|
return SUCCESS;
|
|
}
|
|
}
|
|
|
|
event void RadioControl.startDone(error_t error) {
|
|
#ifdef LPL_SLEEP_INTERVAL
|
|
call LowPowerListening.setLocalWakeupInterval(LPL_SLEEP_INTERVAL);
|
|
#endif
|
|
|
|
if (error == SUCCESS) {
|
|
call Leds.led2Toggle();
|
|
call ExpireTimer.startPeriodic(FRAG_EXPIRE_TIME);
|
|
state = S_RUNNING;
|
|
radioBusy = FALSE;
|
|
}
|
|
|
|
signal SplitControl.startDone(error);
|
|
}
|
|
|
|
event void RadioControl.stopDone(error_t error) {
|
|
signal SplitControl.stopDone(error);
|
|
}
|
|
|
|
command error_t Init.init() {
|
|
// ip_malloc_init needs to be in init, not booted, because
|
|
// context for coap is initialised in init
|
|
ip_malloc_init();
|
|
return SUCCESS;
|
|
}
|
|
|
|
event void Boot.booted() {
|
|
call BlipStatistics.clear();
|
|
|
|
/* set up our reconstruction cache */
|
|
table_init(&recon_cache, recon_data, sizeof(struct lowpan_reconstruct), N_RECONSTRUCTIONS);
|
|
table_map(&recon_cache, reconstruct_clear);
|
|
|
|
call SplitControl.start();
|
|
}
|
|
|
|
/*
|
|
* Receive-side code.
|
|
*/
|
|
void deliver(struct lowpan_reconstruct *recon) {
|
|
struct ip6_hdr *iph = (struct ip6_hdr *)recon->r_buf;
|
|
|
|
// printf("deliver [%i]: ", recon->r_bytes_rcvd);
|
|
// printf_buf(recon->r_buf, recon->r_bytes_rcvd);
|
|
|
|
/* the payload length field is always compressed, have to put it back here */
|
|
iph->ip6_plen = htons(recon->r_bytes_rcvd - sizeof(struct ip6_hdr));
|
|
signal IPLower.recv(iph, (void *)(iph + 1), &recon->r_meta);
|
|
|
|
// printf("ip_free(%p)\n", recon->r_buf);
|
|
ip_free(recon->r_buf);
|
|
recon->r_timeout = T_UNUSED;
|
|
recon->r_buf = NULL;
|
|
}
|
|
|
|
/*
|
|
* Bulletproof recovery logic is very important to make sure we
|
|
* don't get wedged with no free buffers.
|
|
*
|
|
* The table is managed as follows:
|
|
* - unused entries are marked T_UNUSED
|
|
* - entries which
|
|
* o have a buffer allocated
|
|
* o have had a fragment reception before we fired
|
|
* are marked T_ACTIVE
|
|
* - entries which have not had a fragment reception during the last timer period
|
|
* and were active are marked T_ZOMBIE
|
|
* - zombie receptions are deleted: their buffer is freed and table entry marked unused.
|
|
* - when a fragment is dropped, it is entered into the table as T_FAILED1.
|
|
* no buffer is allocated
|
|
* - when the timer fires, T_FAILED1 entries are aged to T_FAILED2.
|
|
* - T_FAILED2 entries are deleted. Incomming fragments with tags
|
|
* that are marked either FAILED1 or FAILED2 are dropped; this
|
|
* prevents us from allocating a buffer for a packet which we
|
|
* have already dropped fragments from.
|
|
*
|
|
*/
|
|
void reconstruct_age(void *elt) {
|
|
struct lowpan_reconstruct *recon = (struct lowpan_reconstruct *)elt;
|
|
if (recon->r_timeout != T_UNUSED)
|
|
printf("recon src: 0x%x tag: 0x%x buf: %p recvd: %i/%i\n",
|
|
recon->r_source_key, recon->r_tag, recon->r_buf,
|
|
recon->r_bytes_rcvd, recon->r_size);
|
|
switch (recon->r_timeout) {
|
|
case T_ACTIVE:
|
|
recon->r_timeout = T_ZOMBIE; break; // age existing receptions
|
|
case T_FAILED1:
|
|
recon->r_timeout = T_FAILED2; break; // age existing receptions
|
|
case T_ZOMBIE:
|
|
case T_FAILED2:
|
|
// deallocate the space for reconstruction
|
|
printf("timing out buffer: src: %i tag: %i\n", recon->r_source_key, recon->r_tag);
|
|
if (recon->r_buf != NULL) {
|
|
printf("ip_free(%p)\n", recon->r_buf);
|
|
ip_free(recon->r_buf);
|
|
}
|
|
recon->r_timeout = T_UNUSED;
|
|
recon->r_buf = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ip_print_heap() {
|
|
#ifdef PRINTFUART_ENABLED
|
|
bndrt_t *cur = (bndrt_t *)heap;
|
|
while (((uint8_t *)cur) - heap < IP_MALLOC_HEAP_SIZE) {
|
|
printf ("heap region start: %p length: %u used: %u\n",
|
|
cur, (*cur & IP_MALLOC_LEN), (*cur & IP_MALLOC_INUSE) >> 15);
|
|
cur = (bndrt_t *)(((uint8_t *)cur) + ((*cur) & IP_MALLOC_LEN));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
event void ExpireTimer.fired() {
|
|
table_map(&recon_cache, reconstruct_age);
|
|
|
|
|
|
printf("Frag pool size: %i\n", call FragPool.size());
|
|
printf("SendInfo pool size: %i\n", call SendInfoPool.size());
|
|
printf("SendEntry pool size: %i\n", call SendEntryPool.size());
|
|
printf("Forward queue length: %i\n", call SendQueue.size());
|
|
ip_print_heap();
|
|
printfflush();
|
|
}
|
|
|
|
/*
|
|
* allocate a structure for recording information about incomming fragments.
|
|
*/
|
|
|
|
struct lowpan_reconstruct *get_reconstruct(uint16_t key, uint16_t tag) {
|
|
struct lowpan_reconstruct *ret = NULL;
|
|
int i;
|
|
|
|
// printf("get_reconstruct: %x %i\n", key, tag);
|
|
|
|
for (i = 0; i < N_RECONSTRUCTIONS; i++) {
|
|
struct lowpan_reconstruct *recon = (struct lowpan_reconstruct *)&recon_data[i];
|
|
|
|
if (recon->r_tag == tag &&
|
|
recon->r_source_key == key) {
|
|
|
|
if (recon->r_timeout > T_UNUSED) {
|
|
recon->r_timeout = T_ACTIVE;
|
|
ret = recon;
|
|
goto done;
|
|
|
|
} else if (recon->r_timeout < T_UNUSED) {
|
|
// if we have already tried and failed to get a buffer, we
|
|
// need to drop remaining fragments.
|
|
ret = NULL;
|
|
goto done;
|
|
}
|
|
}
|
|
if (recon->r_timeout == T_UNUSED)
|
|
ret = recon;
|
|
}
|
|
done:
|
|
// printf("got%p\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
event message_t *Ieee154Receive.receive(message_t *msg, void *msg_payload, uint8_t len) {
|
|
struct packed_lowmsg lowmsg;
|
|
struct ieee154_frame_addr frame_address;
|
|
uint8_t *buf = msg_payload;
|
|
|
|
// printf(" -- RECEIVE -- len : %i\n", len);
|
|
|
|
BLIP_STATS_INCR(stats.rx_total);
|
|
|
|
/* unpack the 802.15.4 address fields */
|
|
buf = unpack_ieee154_hdr(msg_payload, &frame_address);
|
|
len -= buf - (uint8_t *)msg_payload;
|
|
|
|
/* unpack and 6lowpan headers */
|
|
lowmsg.data = buf;
|
|
lowmsg.len = len;
|
|
lowmsg.headers = getHeaderBitmap(&lowmsg);
|
|
if (lowmsg.headers == LOWMSG_NALP) {
|
|
goto fail;
|
|
}
|
|
|
|
if (hasFrag1Header(&lowmsg) || hasFragNHeader(&lowmsg)) {
|
|
// start reassembly
|
|
int rv;
|
|
struct lowpan_reconstruct *recon;
|
|
uint16_t tag, source_key;
|
|
|
|
source_key = ieee154_hashaddr(&frame_address.ieee_src);
|
|
getFragDgramTag(&lowmsg, &tag);
|
|
recon = get_reconstruct(source_key, tag);
|
|
if (!recon) {
|
|
goto fail;
|
|
}
|
|
|
|
/* fill in metadata: on fragmented packets, it applies to the
|
|
first fragment only */
|
|
memcpy(&recon->r_meta.sender, &frame_address.ieee_src,
|
|
sizeof(ieee154_addr_t));
|
|
recon->r_meta.lqi = call ReadLqi.readLqi(msg);
|
|
recon->r_meta.rssi = call ReadLqi.readRssi(msg);
|
|
|
|
if (hasFrag1Header(&lowmsg)) {
|
|
if (recon->r_buf != NULL) goto fail;
|
|
rv = lowpan_recon_start(&frame_address, recon, buf, len);
|
|
} else {
|
|
rv = lowpan_recon_add(recon, buf, len);
|
|
}
|
|
|
|
if (rv < 0) {
|
|
recon->r_timeout = T_FAILED1;
|
|
goto fail;
|
|
} else {
|
|
// printf("start recon buf: %p\n", recon->r_buf);
|
|
recon->r_timeout = T_ACTIVE;
|
|
recon->r_source_key = source_key;
|
|
recon->r_tag = tag;
|
|
}
|
|
|
|
if (recon->r_size == recon->r_bytes_rcvd) {
|
|
deliver(recon);
|
|
}
|
|
|
|
} else {
|
|
/* no fragmentation, just deliver it */
|
|
int rv;
|
|
struct lowpan_reconstruct recon;
|
|
|
|
/* fill in metadata */
|
|
memcpy(&recon.r_meta.sender, &frame_address.ieee_src,
|
|
sizeof(ieee154_addr_t));
|
|
recon.r_meta.lqi = call ReadLqi.readLqi(msg);
|
|
recon.r_meta.rssi = call ReadLqi.readRssi(msg);
|
|
|
|
buf = getLowpanPayload(&lowmsg);
|
|
if ((rv = lowpan_recon_start(&frame_address, &recon, buf, len)) < 0) {
|
|
goto fail;
|
|
}
|
|
|
|
if (recon.r_size == recon.r_bytes_rcvd) {
|
|
deliver(&recon);
|
|
} else {
|
|
// printf("ip_free(%p)\n", recon.r_buf);
|
|
ip_free(recon.r_buf);
|
|
}
|
|
}
|
|
goto done;
|
|
fail:
|
|
BLIP_STATS_INCR(stats.rx_drop);
|
|
done:
|
|
return msg;
|
|
}
|
|
|
|
|
|
/*
|
|
* Send-side functionality
|
|
*/
|
|
task void sendTask() {
|
|
struct send_entry *s_entry;
|
|
|
|
// printf("sendTask() - sending\n");
|
|
|
|
if (radioBusy || state != S_RUNNING) return;
|
|
if (call SendQueue.empty()) return;
|
|
// this does not dequeue
|
|
s_entry = call SendQueue.head();
|
|
|
|
#ifdef LPL_SLEEP_INTERVAL
|
|
call LowPowerListening.setRemoteWakeupInterval(s_entry->msg,
|
|
call LowPowerListening.getLocalWakeupInterval());
|
|
#endif
|
|
|
|
if (s_entry->info->failed) {
|
|
dbg("Drops", "drops: sendTask: dropping failed fragment\n");
|
|
goto fail;
|
|
}
|
|
|
|
if ((call Ieee154Send.send(s_entry->msg,
|
|
call BarePacket.payloadLength(s_entry->msg))) != SUCCESS) {
|
|
dbg("Drops", "drops: sendTask: send failed\n");
|
|
goto fail;
|
|
} else {
|
|
radioBusy = TRUE;
|
|
}
|
|
|
|
return;
|
|
fail:
|
|
printf("SEND FAIL\n");
|
|
post sendTask();
|
|
BLIP_STATS_INCR(stats.tx_drop);
|
|
|
|
// deallocate the memory associated with this request.
|
|
// other fragments associated with this packet will get dropped.
|
|
s_entry->info->failed = TRUE;
|
|
SENDINFO_DECR(s_entry->info);
|
|
call FragPool.put(s_entry->msg);
|
|
call SendEntryPool.put(s_entry);
|
|
call SendQueue.dequeue();
|
|
}
|
|
|
|
|
|
/*
|
|
* it will pack the message into the fragment pool and enqueue
|
|
* those fragments for sending
|
|
*
|
|
* it will set
|
|
* - payload length
|
|
* - version, traffic class and flow label
|
|
*
|
|
* the source and destination IP addresses must be set by higher
|
|
* layers.
|
|
*/
|
|
command error_t IPLower.send(struct ieee154_frame_addr *frame_addr,
|
|
struct ip6_packet *msg,
|
|
void *data) {
|
|
struct lowpan_ctx ctx;
|
|
struct send_info *s_info;
|
|
struct send_entry *s_entry;
|
|
message_t *outgoing;
|
|
|
|
int frag_len = 1;
|
|
error_t rc = SUCCESS;
|
|
|
|
if (state != S_RUNNING) {
|
|
return EOFF;
|
|
}
|
|
|
|
/* set version to 6 in case upper layers forgot */
|
|
msg->ip6_hdr.ip6_vfc &= ~IPV6_VERSION_MASK;
|
|
msg->ip6_hdr.ip6_vfc |= IPV6_VERSION;
|
|
|
|
ctx.tag = current_local_label++;
|
|
ctx.offset = 0;
|
|
|
|
s_info = getSendInfo();
|
|
if (s_info == NULL) {
|
|
rc = ERETRY;
|
|
goto cleanup_outer;
|
|
}
|
|
s_info->upper_data = data;
|
|
|
|
while (frag_len > 0) {
|
|
s_entry = call SendEntryPool.get();
|
|
outgoing = call FragPool.get();
|
|
|
|
if (s_entry == NULL || outgoing == NULL) {
|
|
if (s_entry != NULL)
|
|
call SendEntryPool.put(s_entry);
|
|
if (outgoing != NULL)
|
|
call FragPool.put(outgoing);
|
|
// this will cause any fragments we have already enqueued to
|
|
// be dropped by the send task.
|
|
s_info->failed = TRUE;
|
|
printf("drops: IP send: no fragments\n");
|
|
rc = ERETRY;
|
|
goto done;
|
|
}
|
|
|
|
call BarePacket.clear(outgoing);
|
|
frag_len = lowpan_frag_get(call Ieee154Send.getPayload(outgoing, 0),
|
|
call BarePacket.maxPayloadLength(),
|
|
msg,
|
|
frame_addr,
|
|
&ctx);
|
|
if (frag_len < 0) {
|
|
printf(" get frag error: %i\n", frag_len);
|
|
}
|
|
|
|
printf("fragment length: %i offset: %i\n", frag_len, ctx.offset);
|
|
call BarePacket.setPayloadLength(outgoing, frag_len);
|
|
|
|
if (frag_len <= 0) {
|
|
call FragPool.put(outgoing);
|
|
call SendEntryPool.put(s_entry);
|
|
goto done;
|
|
}
|
|
|
|
if (call SendQueue.enqueue(s_entry) != SUCCESS) {
|
|
BLIP_STATS_INCR(stats.encfail);
|
|
s_info->failed = TRUE;
|
|
printf("drops: IP send: enqueue failed\n");
|
|
goto done;
|
|
}
|
|
|
|
s_info->link_fragments++;
|
|
s_entry->msg = outgoing;
|
|
s_entry->info = s_info;
|
|
|
|
/* configure the L2 */
|
|
if (frame_addr->ieee_dst.ieee_mode == IEEE154_ADDR_SHORT &&
|
|
frame_addr->ieee_dst.i_saddr == IEEE154_BROADCAST_ADDR) {
|
|
call PacketLink.setRetries(s_entry->msg, 0);
|
|
} else {
|
|
call PacketLink.setRetries(s_entry->msg, BLIP_L2_RETRIES);
|
|
}
|
|
call PacketLink.setRetryDelay(s_entry->msg, BLIP_L2_DELAY);
|
|
|
|
SENDINFO_INCR(s_info);}
|
|
|
|
// printf("got %i frags\n", s_info->link_fragments);
|
|
done:
|
|
BLIP_STATS_INCR(stats.sent);
|
|
SENDINFO_DECR(s_info);
|
|
post sendTask();
|
|
cleanup_outer:
|
|
return rc;
|
|
}
|
|
|
|
event void Ieee154Send.sendDone(message_t *msg, error_t error) {
|
|
struct send_entry *s_entry = call SendQueue.head();
|
|
|
|
radioBusy = FALSE;
|
|
|
|
// printf("sendDone: %p %i\n", msg, error);
|
|
|
|
if (state == S_STOPPING) {
|
|
call RadioControl.stop();
|
|
state = S_STOPPED;
|
|
goto done;
|
|
}
|
|
|
|
s_entry->info->link_transmissions += (call PacketLink.getRetries(msg));
|
|
s_entry->info->link_fragment_attempts++;
|
|
|
|
if (!call PacketLink.wasDelivered(msg)) {
|
|
printf("sendDone: was not delivered! (%i tries)\n",
|
|
call PacketLink.getRetries(msg));
|
|
s_entry->info->failed = TRUE;
|
|
signal IPLower.sendDone(s_entry->info);
|
|
/* if (s_entry->info->policy.dest[0] != 0xffff) */
|
|
/* dbg("Drops", "drops: sendDone: frag was not delivered\n"); */
|
|
// need to check for broadcast frames
|
|
// BLIP_STATS_INCR(stats.tx_drop);
|
|
} else if (s_entry->info->link_fragment_attempts ==
|
|
s_entry->info->link_fragments) {
|
|
signal IPLower.sendDone(s_entry->info);
|
|
}
|
|
|
|
done:
|
|
// kill off any pending fragments
|
|
SENDINFO_DECR(s_entry->info);
|
|
call FragPool.put(s_entry->msg);
|
|
call SendEntryPool.put(s_entry);
|
|
call SendQueue.dequeue();
|
|
|
|
post sendTask();
|
|
}
|
|
|
|
#if 0
|
|
command struct tlv_hdr *IPExtensions.findTlv(struct ip6_ext *ext, uint8_t tlv_val) {
|
|
int len = ext->len - sizeof(struct ip6_ext);
|
|
struct tlv_hdr *tlv = (struct tlv_hdr *)(ext + 1);
|
|
while (len > 0) {
|
|
if (tlv->type == tlv_val) return tlv;
|
|
if (tlv->len == 0) return NULL;
|
|
tlv = (struct tlv_hdr *)(((uint8_t *)tlv) + tlv->len);
|
|
len -= tlv->len;
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
* BlipStatistics interface
|
|
*/
|
|
command void BlipStatistics.get(ip_statistics_t *statistics) {
|
|
#ifdef BLIP_STATS_IP_MEM
|
|
stats.fragpool = call FragPool.size();
|
|
stats.sendinfo = call SendInfoPool.size();
|
|
stats.sendentry= call SendEntryPool.size();
|
|
stats.sndqueue = call SendQueue.size();
|
|
stats.heapfree = ip_malloc_freespace();
|
|
printf("frag: %i sendinfo: %i sendentry: %i sendqueue: %i heap: %i\n",
|
|
stats.fragpool,
|
|
stats.sendinfo,
|
|
stats.sendentry,
|
|
stats.sndqueue,
|
|
stats.heapfree);
|
|
#endif
|
|
memcpy(statistics, &stats, sizeof(ip_statistics_t));
|
|
|
|
}
|
|
|
|
command void BlipStatistics.clear() {
|
|
memclr((uint8_t *)&stats, sizeof(ip_statistics_t));
|
|
}
|
|
|
|
/* default event void IP.recv[uint8_t nxt_hdr](struct ip6_hdr *iph, */
|
|
/* void *payload, */
|
|
/* struct ip_metadata *meta) { */
|
|
/* } */
|
|
|
|
/* default event void Multicast.recv[uint8_t scope](struct ip6_hdr *iph, */
|
|
/* void *payload, */
|
|
/* struct ip_metadata *meta) { */
|
|
/* } */
|
|
}
|