Added streaming mode for page updates. Rewrote and removed some legacy code. Improved error checks and comments.

This commit is contained in:
Nicolas Tsiftes 2011-06-14 17:12:15 +02:00
parent 48e6e801c2
commit ddd245ed15
2 changed files with 95 additions and 88 deletions

View file

@ -33,10 +33,10 @@
/** /**
* \file * \file
* The Deluge protocol for data dissemination. * An implementation of the Deluge protocol.
* (Hui and Culler: The dynamic behavior of a data * (Hui and Culler: The dynamic behavior of a data
* dissemination protocol for network programming at scale, * dissemination protocol for network programming at scale,
* SenSys 2004) * ACM SenSys 2004)
* \author * \author
* Nicolas Tsiftes <nvt@sics.se> * Nicolas Tsiftes <nvt@sics.se>
*/ */
@ -67,11 +67,6 @@
#define PRINTF(...) #define PRINTF(...)
#endif #endif
PROCESS(deluge_process, "Deluge process");
static void broadcast_recv(struct broadcast_conn *, const rimeaddr_t *);
static void unicast_recv(struct unicast_conn *, const rimeaddr_t *);
/* Implementation-specific variables. */ /* Implementation-specific variables. */
static struct broadcast_conn deluge_broadcast; static struct broadcast_conn deluge_broadcast;
static struct unicast_conn deluge_uc; static struct unicast_conn deluge_uc;
@ -86,32 +81,25 @@ static unsigned r_interval;
static unsigned recv_adv; static unsigned recv_adv;
static int broadcast_profile; static int broadcast_profile;
/* Deluge timers. */
static struct ctimer rx_timer; static struct ctimer rx_timer;
static struct ctimer tx_timer; static struct ctimer tx_timer;
static struct ctimer summary_timer; static struct ctimer summary_timer;
static struct ctimer profile_timer; static struct ctimer profile_timer;
static unsigned next_object_id; /* Deluge objects will get an ID that defaults to the current value of
the next_object_id parameter. */
static deluge_object_id_t next_object_id;
/* Rime callbacks. */
static void broadcast_recv(struct broadcast_conn *, const rimeaddr_t *);
static void unicast_recv(struct unicast_conn *, const rimeaddr_t *);
static const struct broadcast_callbacks broadcast_call = {broadcast_recv, NULL}; static const struct broadcast_callbacks broadcast_call = {broadcast_recv, NULL};
static const struct unicast_callbacks unicast_call = {unicast_recv, NULL}; static const struct unicast_callbacks unicast_call = {unicast_recv, NULL};
#if NETSIM /* The Deluge process manages the main Deluge timer. */
static char label[128]; PROCESS(deluge_process, "Deluge");
#endif
static uint16_t
checksum(unsigned char *buf, unsigned len)
{
unsigned i;
uint16_t sum;
for(i = sum = 0; i < len; i++) {
sum = crc16_add(buf[i], sum);
}
return sum;
}
static void static void
transition(int state) transition(int state)
@ -136,15 +124,26 @@ transition(int state)
static int static int
write_page(struct deluge_object *obj, unsigned pagenum, unsigned char *data) write_page(struct deluge_object *obj, unsigned pagenum, unsigned char *data)
{ {
cfs_seek(obj->cfs_fd, pagenum * S_PAGE, CFS_SEEK_SET); cfs_offset_t offset;
return cfs_write(obj->cfs_fd, (char *)data,
S_PAGE); offset = pagenum * S_PAGE;
if(cfs_seek(obj->cfs_fd, offset, CFS_SEEK_SET) != offset) {
return -1;
}
return cfs_write(obj->cfs_fd, (char *)data, S_PAGE);
} }
static int static int
read_page(struct deluge_object *obj, unsigned pagenum, unsigned char *buf) read_page(struct deluge_object *obj, unsigned pagenum, unsigned char *buf)
{ {
cfs_seek(obj->cfs_fd, pagenum * S_PAGE, CFS_SEEK_SET); cfs_offset_t offset;
offset = pagenum * S_PAGE;
if(cfs_seek(obj->cfs_fd, offset, CFS_SEEK_SET) != offset) {
return -1;
}
return cfs_read(obj->cfs_fd, (char *)buf, S_PAGE); return cfs_read(obj->cfs_fd, (char *)buf, S_PAGE);
} }
@ -165,26 +164,27 @@ init_page(struct deluge_object *obj, int pagenum, int have)
page->packet_set = ALL_PACKETS; page->packet_set = ALL_PACKETS;
page->flags |= PAGE_COMPLETE; page->flags |= PAGE_COMPLETE;
read_page(obj, pagenum, buf); read_page(obj, pagenum, buf);
page->crc = checksum(buf, S_PAGE); page->crc = crc16_data(buf, S_PAGE, 0);
} else { } else {
page->version = 0; page->version = 0;
page->packet_set = 0; page->packet_set = 0;
} }
} }
static int static cfs_offset_t
file_size(const char *file) file_size(const char *file)
{ {
int fd, size; int fd;
cfs_offset_t size;
fd = cfs_open(file, CFS_READ); fd = cfs_open(file, CFS_READ);
if(fd < 0) { if(fd < 0) {
return -1; return (cfs_offset_t)-1;
} }
size = cfs_seek(fd, 0, CFS_SEEK_END); size = cfs_seek(fd, 0, CFS_SEEK_END);
cfs_close(fd); cfs_close(fd);
return size; return size;
} }
@ -209,6 +209,7 @@ init_object(struct deluge_object *obj, char *filename, unsigned version)
obj->pages = malloc(OBJECT_PAGE_COUNT(*obj) * sizeof(*obj->pages)); obj->pages = malloc(OBJECT_PAGE_COUNT(*obj) * sizeof(*obj->pages));
if(obj->pages == NULL) { if(obj->pages == NULL) {
cfs_close(obj->cfs_fd);
return -1; return -1;
} }
@ -217,7 +218,7 @@ init_object(struct deluge_object *obj, char *filename, unsigned version)
init_page(&current_object, i, 1); init_page(&current_object, i, 1);
} }
memset(obj->current_page, 0, sizeof (obj->current_page)); memset(obj->current_page, 0, sizeof(obj->current_page));
return 0; return 0;
} }
@ -244,15 +245,15 @@ send_request(void *arg)
obj = (struct deluge_object *)arg; obj = (struct deluge_object *)arg;
request.object_id = obj->object_id;
request.cmd = DELUGE_CMD_REQUEST; request.cmd = DELUGE_CMD_REQUEST;
request.pagenum = obj->current_rx_page; request.pagenum = obj->current_rx_page;
request.version = obj->pages[request.pagenum].version; request.version = obj->pages[request.pagenum].version;
request.request_set = ~obj->pages[obj->current_rx_page].packet_set; request.request_set = ~obj->pages[obj->current_rx_page].packet_set;
request.object_id = obj->object_id;
PRINTF("Sending request for page %d, version %u, request_set %u\n", PRINTF("Sending request for page %d, version %u, request_set %u\n",
request.pagenum, request.version, request.request_set); request.pagenum, request.version, request.request_set);
packetbuf_copyfrom((uint8_t *)&request, sizeof (request)); packetbuf_copyfrom(&request, sizeof(request));
unicast_send(&deluge_uc, &obj->summary_from); unicast_send(&deluge_uc, &obj->summary_from);
/* Deluge R.2 */ /* Deluge R.2 */
@ -276,14 +277,14 @@ advertise_summary(struct deluge_object *obj)
} }
summary.cmd = DELUGE_CMD_SUMMARY; summary.cmd = DELUGE_CMD_SUMMARY;
summary.object_id = obj->object_id;
summary.version = obj->update_version; summary.version = obj->update_version;
summary.highest_available = highest_available_page(obj); summary.highest_available = highest_available_page(obj);
summary.object_id = obj->object_id;
PRINTF("Advertising summary for object id %u: version=%u, available=%u\n", PRINTF("Advertising summary for object id %u: version=%u, available=%u\n",
(unsigned) obj->object_id, summary.version, summary.highest_available); (unsigned)obj->object_id, summary.version, summary.highest_available);
packetbuf_copyfrom((uint8_t *)&summary, sizeof (summary)); packetbuf_copyfrom(&summary, sizeof(summary));
broadcast_send(&deluge_broadcast); broadcast_send(&deluge_broadcast);
} }
@ -351,10 +352,10 @@ send_page(struct deluge_object *obj, unsigned pagenum)
unsigned char *cp; unsigned char *cp;
pkt.cmd = DELUGE_CMD_PACKET; pkt.cmd = DELUGE_CMD_PACKET;
pkt.object_id = obj->object_id;
pkt.pagenum = pagenum; pkt.pagenum = pagenum;
pkt.version = obj->pages[pagenum].version; pkt.version = obj->pages[pagenum].version;
pkt.packetnum = 0; pkt.packetnum = 0;
pkt.object_id = obj->object_id;
pkt.crc = 0; pkt.crc = 0;
read_page(obj, pagenum, buf); read_page(obj, pagenum, buf);
@ -362,9 +363,9 @@ send_page(struct deluge_object *obj, unsigned pagenum)
/* Divide the page into packets and send them one at a time. */ /* Divide the page into packets and send them one at a time. */
for(cp = buf; cp + S_PKT <= (unsigned char *)&buf[S_PAGE]; cp += S_PKT) { for(cp = buf; cp + S_PKT <= (unsigned char *)&buf[S_PAGE]; cp += S_PKT) {
if(obj->tx_set & (1 << pkt.packetnum)) { if(obj->tx_set & (1 << pkt.packetnum)) {
pkt.crc = checksum(cp, S_PKT); pkt.crc = crc16_data(cp, S_PKT, 0);
memcpy(pkt.payload, cp, S_PKT); memcpy(pkt.payload, cp, S_PKT);
packetbuf_copyfrom((uint8_t *)&pkt, sizeof (pkt)); packetbuf_copyfrom(&pkt, sizeof(pkt));
broadcast_send(&deluge_broadcast); broadcast_send(&deluge_broadcast);
} }
pkt.packetnum++; pkt.packetnum++;
@ -382,8 +383,12 @@ tx_callback(void *arg)
send_page(obj, obj->current_tx_page); send_page(obj, obj->current_tx_page);
/* Deluge T.2. */ /* Deluge T.2. */
if(obj->tx_set) { if(obj->tx_set) {
packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE,
PACKETBUF_ATTR_PACKET_TYPE_STREAM);
ctimer_reset(&tx_timer); ctimer_reset(&tx_timer);
} else { } else {
packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE,
PACKETBUF_ATTR_PACKET_TYPE_STREAM_END);
obj->current_tx_page = -1; obj->current_tx_page = -1;
transition(DELUGE_STATE_MAINTAIN); transition(DELUGE_STATE_MAINTAIN);
} }
@ -449,7 +454,7 @@ handle_packet(struct deluge_msg_packet *msg)
memcpy(&current_object.current_page[S_PKT * packet.packetnum], memcpy(&current_object.current_page[S_PKT * packet.packetnum],
packet.payload, S_PKT); packet.payload, S_PKT);
crc = checksum(packet.payload, S_PKT); crc = crc16_data(packet.payload, S_PKT, 0);
if(packet.crc != crc) { if(packet.crc != crc) {
PRINTF("packet crc: %hu, calculated crc: %hu\n", packet.crc, crc); PRINTF("packet crc: %hu, calculated crc: %hu\n", packet.crc, crc);
return; return;
@ -459,6 +464,10 @@ handle_packet(struct deluge_msg_packet *msg)
page->packet_set |= (1 << packet.packetnum); page->packet_set |= (1 << packet.packetnum);
if(page->packet_set == ALL_PACKETS) { if(page->packet_set == ALL_PACKETS) {
/* This is the last packet of the requested page; stop streaming. */
packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE,
PACKETBUF_ATTR_PACKET_TYPE_STREAM_END);
write_page(&current_object, packet.pagenum, current_object.current_page); write_page(&current_object, packet.pagenum, current_object.current_page);
page->version = packet.version; page->version = packet.version;
page->flags = PAGE_COMPLETE; page->flags = PAGE_COMPLETE;
@ -470,7 +479,7 @@ handle_packet(struct deluge_msg_packet *msg)
current_object.version = current_object.update_version; current_object.version = current_object.update_version;
leds_on(LEDS_RED); leds_on(LEDS_RED);
PRINTF("Update completed for object %u, version %u\n", PRINTF("Update completed for object %u, version %u\n",
current_object.object_id, packet.version); (unsigned)current_object.object_id, packet.version);
} else if(current_object.current_rx_page < OBJECT_PAGE_COUNT(current_object)) { } else if(current_object.current_rx_page < OBJECT_PAGE_COUNT(current_object)) {
if(ctimer_expired(&rx_timer)) { if(ctimer_expired(&rx_timer)) {
ctimer_set(&rx_timer, ctimer_set(&rx_timer,
@ -480,36 +489,19 @@ handle_packet(struct deluge_msg_packet *msg)
} }
/* Deluge R.3 */ /* Deluge R.3 */
transition(DELUGE_STATE_MAINTAIN); transition(DELUGE_STATE_MAINTAIN);
} else {
/* More packets to come. Put lower layers in streaming mode. */
packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE,
PACKETBUF_ATTR_PACKET_TYPE_STREAM);
} }
} }
} }
static void
unicast_recv(struct unicast_conn *c, const rimeaddr_t *sender)
{
char *msg;
int len;
msg = packetbuf_dataptr();
len = packetbuf_datalen();
if(len < 5)
return;
switch(msg[2]) {
case DELUGE_CMD_REQUEST:
if(len >= sizeof (struct deluge_msg_request))
handle_request((struct deluge_msg_request *)msg);
break;
default:
PRINTF("Incoming packet with unknown command!\n");
}
}
static void static void
send_profile(struct deluge_object *obj) send_profile(struct deluge_object *obj)
{ {
struct deluge_msg_profile *msg; struct deluge_msg_profile *msg;
unsigned char buf[sizeof (*msg) + OBJECT_PAGE_COUNT(*obj)]; unsigned char buf[sizeof(*msg) + OBJECT_PAGE_COUNT(*obj)];
int i; int i;
if(broadcast_profile && recv_adv < CONST_K) { if(broadcast_profile && recv_adv < CONST_K) {
@ -517,14 +509,14 @@ send_profile(struct deluge_object *obj)
msg = (struct deluge_msg_profile *)buf; msg = (struct deluge_msg_profile *)buf;
msg->cmd = DELUGE_CMD_PROFILE; msg->cmd = DELUGE_CMD_PROFILE;
msg->object_id = obj->object_id;
msg->version = obj->version; msg->version = obj->version;
msg->npages = OBJECT_PAGE_COUNT(*obj); msg->npages = OBJECT_PAGE_COUNT(*obj);
msg->object_id = obj->object_id;
for(i = 0; i < msg->npages; i++) { for(i = 0; i < msg->npages; i++) {
msg->version_vector[i] = obj->pages[i].version; msg->version_vector[i] = obj->pages[i].version;
} }
packetbuf_copyfrom(buf, sizeof (buf)); packetbuf_copyfrom(buf, sizeof(buf));
broadcast_send(&deluge_broadcast); broadcast_send(&deluge_broadcast);
} }
} }
@ -551,13 +543,13 @@ handle_profile(struct deluge_msg_profile *msg)
npages = OBJECT_PAGE_COUNT(*obj); npages = OBJECT_PAGE_COUNT(*obj);
obj->size = msg->npages * S_PAGE; obj->size = msg->npages * S_PAGE;
p = malloc(OBJECT_PAGE_COUNT(*obj) * sizeof (*obj->pages)); p = malloc(OBJECT_PAGE_COUNT(*obj) * sizeof(*obj->pages));
if(p == NULL) { if(p == NULL) {
PRINTF("Failed to reallocate memory for pages!\n"); PRINTF("Failed to reallocate memory for pages!\n");
return; return;
} }
memcpy(p, obj->pages, npages * sizeof (*obj->pages)); memcpy(p, obj->pages, npages * sizeof(*obj->pages));
free(obj->pages); free(obj->pages);
obj->pages = (struct deluge_page *)p; obj->pages = (struct deluge_page *)p;
@ -588,7 +580,7 @@ handle_profile(struct deluge_msg_profile *msg)
} }
static void static void
broadcast_recv(struct broadcast_conn *c, const rimeaddr_t *sender) command_dispatcher(const rimeaddr_t *sender)
{ {
char *msg; char *msg;
int len; int len;
@ -596,37 +588,50 @@ broadcast_recv(struct broadcast_conn *c, const rimeaddr_t *sender)
msg = packetbuf_dataptr(); msg = packetbuf_dataptr();
len = packetbuf_datalen(); len = packetbuf_datalen();
if(len < 5) if(len < 1)
return; return;
switch(msg[2]) { switch(msg[0]) {
case DELUGE_CMD_SUMMARY: case DELUGE_CMD_SUMMARY:
if(len >= sizeof (struct deluge_msg_summary)) if(len >= sizeof(struct deluge_msg_summary))
handle_summary((struct deluge_msg_summary *)msg, sender); handle_summary((struct deluge_msg_summary *)msg, sender);
break; break;
case DELUGE_CMD_REQUEST: case DELUGE_CMD_REQUEST:
if(len >= sizeof (struct deluge_msg_request)) if(len >= sizeof(struct deluge_msg_request))
handle_request((struct deluge_msg_request *)msg); handle_request((struct deluge_msg_request *)msg);
break; break;
case DELUGE_CMD_PACKET: case DELUGE_CMD_PACKET:
if(len >= sizeof (struct deluge_msg_packet)) if(len >= sizeof(struct deluge_msg_packet))
handle_packet((struct deluge_msg_packet *)msg); handle_packet((struct deluge_msg_packet *)msg);
break; break;
case DELUGE_CMD_PROFILE: case DELUGE_CMD_PROFILE:
profile = (struct deluge_msg_profile *)msg; profile = (struct deluge_msg_profile *)msg;
if(len >= sizeof (*profile) && if(len >= sizeof(*profile) &&
len >= sizeof (*profile) + profile->npages * profile->version_vector[0]) len >= sizeof(*profile) + profile->npages * profile->version_vector[0])
handle_profile((struct deluge_msg_profile *)msg); handle_profile((struct deluge_msg_profile *)msg);
break; break;
default: default:
PRINTF("Incoming packet with unknown command!\n"); PRINTF("Incoming packet with unknown command: %d\n", msg[0]);
} }
} }
static void
unicast_recv(struct unicast_conn *c, const rimeaddr_t *sender)
{
command_dispatcher(sender);
}
static void
broadcast_recv(struct broadcast_conn *c, const rimeaddr_t *sender)
{
command_dispatcher(sender);
}
int int
deluge_disseminate(char *file, unsigned version) deluge_disseminate(char *file, unsigned version)
{ {
if(init_object(&current_object, file, version) < 0) { /* This implementation disseminates at most one object. */
if(next_object_id > 0 || init_object(&current_object, file, version) < 0) {
return -1; return -1;
} }
process_start(&deluge_process, file); process_start(&deluge_process, file);

View file

@ -95,38 +95,40 @@ PROCESS_NAME(deluge_process);
#define CONST_OMEGA 8 #define CONST_OMEGA 8
#define ESTIMATED_TX_TIME (CLOCK_SECOND) #define ESTIMATED_TX_TIME (CLOCK_SECOND)
typedef uint8_t deluge_object_id_t;
struct deluge_msg_summary { struct deluge_msg_summary {
uint16_t object_id;
uint8_t cmd; uint8_t cmd;
uint8_t version; uint8_t version;
uint8_t highest_available; uint8_t highest_available;
} __attribute__((packed)); deluge_object_id_t object_id;
};
struct deluge_msg_request { struct deluge_msg_request {
uint16_t object_id;
uint8_t cmd; uint8_t cmd;
uint8_t version; uint8_t version;
uint8_t pagenum; uint8_t pagenum;
uint8_t request_set; uint8_t request_set;
} __attribute__((packed)); deluge_object_id_t object_id;
};
struct deluge_msg_packet { struct deluge_msg_packet {
uint16_t object_id;
uint8_t cmd; uint8_t cmd;
uint8_t version; uint8_t version;
uint8_t pagenum; uint8_t pagenum;
uint8_t packetnum; uint8_t packetnum;
uint16_t crc; uint16_t crc;
deluge_object_id_t object_id;
unsigned char payload[S_PKT]; unsigned char payload[S_PKT];
} __attribute__((packed)); };
struct deluge_msg_profile { struct deluge_msg_profile {
uint16_t object_id;
uint8_t cmd; uint8_t cmd;
uint8_t version; uint8_t version;
uint8_t npages; uint8_t npages;
deluge_object_id_t object_id;
uint8_t version_vector[]; uint8_t version_vector[];
} __attribute__((packed)); };
struct deluge_object { struct deluge_object {
char *filename; char *filename;