From 4fa44208eb3663f60a9fc67e0424ef4436e0ceeb Mon Sep 17 00:00:00 2001 From: adamdunkels Date: Sun, 25 Mar 2007 12:07:38 +0000 Subject: [PATCH] Moved rudolph{0,1} into core/net/rime --- apps/rudolph/Makefile.rudolph | 1 - apps/rudolph/rudolph0.c | 231 --------------------------- apps/rudolph/rudolph0.h | 95 ----------- apps/rudolph/rudolph1.c | 292 ---------------------------------- apps/rudolph/rudolph1.h | 81 ---------- 5 files changed, 700 deletions(-) delete mode 100644 apps/rudolph/Makefile.rudolph delete mode 100644 apps/rudolph/rudolph0.c delete mode 100644 apps/rudolph/rudolph0.h delete mode 100644 apps/rudolph/rudolph1.c delete mode 100644 apps/rudolph/rudolph1.h diff --git a/apps/rudolph/Makefile.rudolph b/apps/rudolph/Makefile.rudolph deleted file mode 100644 index 7cccf552c..000000000 --- a/apps/rudolph/Makefile.rudolph +++ /dev/null @@ -1 +0,0 @@ -APP_SOURCES += rudolph0.c rudolph1.c diff --git a/apps/rudolph/rudolph0.c b/apps/rudolph/rudolph0.c deleted file mode 100644 index dd3be2db4..000000000 --- a/apps/rudolph/rudolph0.c +++ /dev/null @@ -1,231 +0,0 @@ -/* - * Copyright (c) 2007, Swedish Institute of Computer Science. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of the Institute nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * This file is part of the Contiki operating system. - * - * $Id: rudolph0.c,v 1.4 2007/03/23 10:46:56 adamdunkels Exp $ - */ - -/** - * \file - * Rudolph0: a simple block data flooding protocol - * \author - * Adam Dunkels - */ - -#include "net/rime.h" -#include "rudolph0.h" - -#include /* for offsetof */ - -#define SENDING_TIME CLOCK_SECOND / 2 -#define STEADY_TIME CLOCK_SECOND * 2 - -enum { - TYPE_DATA, - TYPE_NACK, -}; - -enum { - STATE_RECEIVER, - STATE_SENDER, -}; - -#define VERSION_LT(a, b) ((signed char)((a) - (b)) < 0) - -#define DEBUG 0 -#if DEBUG -#include -#define PRINTF(...) printf(__VA_ARGS__) -#else -#define PRINTF(...) -#endif - -/*---------------------------------------------------------------------------*/ -static void -read_new_datapacket(struct rudolph0_conn *c) -{ - int len = 0; - - if(c->cb->read_chunk) { - len = c->cb->read_chunk(c, c->current.h.chunk * RUDOLPH0_DATASIZE, - c->current.data, RUDOLPH0_DATASIZE); - } - c->current.datalen = len; - - PRINTF("read_new_datapacket len %d\n", len); -} -/*---------------------------------------------------------------------------*/ -static void -send_nack(struct rudolph0_conn *c) -{ - struct rudolph0_hdr *hdr; - rimebuf_clear(); - rimebuf_hdralloc(sizeof(struct rudolph0_hdr)); - hdr = rimebuf_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); - uabc_send(&c->nackc, CLOCK_SECOND / 4); -} -/*---------------------------------------------------------------------------*/ -static void -sent(struct sabc_conn *sabc) -{ - struct rudolph0_conn *c = (struct rudolph0_conn *)sabc; - - if(c->current.datalen == RUDOLPH0_DATASIZE) { - c->current.h.chunk++; - PRINTF("Sending data chunk %d next time\n", c->current.h.chunk); - read_new_datapacket(c); - } else { - sabc_set_timer(&c->c, STEADY_TIME); - PRINTF("Steady: Sending the same data chunk next time datalen %d, %d\n", - c->current.datalen, RUDOLPH0_DATASIZE); - } -} -/*---------------------------------------------------------------------------*/ -static void -recv(struct sabc_conn *sabc) -{ - struct rudolph0_conn *c = (struct rudolph0_conn *)sabc; - struct rudolph0_datapacket *p = rimebuf_dataptr(); - - /* if(rand() & 1) { - return; - }*/ - - if(p->h.type == TYPE_DATA) { - if(c->current.h.version != p->h.version) { - PRINTF("rudolph0 new version %d\n", p->h.version); - c->current.h.version = p->h.version; - c->current.h.chunk = 0; - c->cb->write_chunk(c, 0, RUDOLPH0_FLAG_NEWFILE, p->data, 0); - if(p->h.chunk != 0) { - send_nack(c); - } else { - c->cb->write_chunk(c, 0, RUDOLPH0_FLAG_NONE, p->data, p->datalen); - c->current.h.chunk++; - } - } else if(p->h.version == c->current.h.version) { - if(p->h.chunk == c->current.h.chunk) { - PRINTF("received chunk %d\n", p->h.chunk); - if(p->datalen < RUDOLPH0_DATASIZE) { - c->cb->write_chunk(c, c->current.h.chunk * RUDOLPH0_DATASIZE, - RUDOLPH0_FLAG_LASTCHUNK, p->data, p->datalen); - } else { - c->cb->write_chunk(c, c->current.h.chunk * RUDOLPH0_DATASIZE, - RUDOLPH0_FLAG_NONE, p->data, p->datalen); - } - c->current.h.chunk++; - - } else if(p->h.chunk > c->current.h.chunk) { - PRINTF("received chunk %d > %d, sending NACK\n", p->h.chunk, c->current.h.chunk); - send_nack(c); - } - } else { /* p->h.version < c->current.h.version */ - /* Ignore packets with old version */ - } - } -} -/*---------------------------------------------------------------------------*/ -static void -recv_nack(struct uabc_conn *uabc) -{ - struct rudolph0_conn *c = (struct rudolph0_conn *) - ((char *)uabc - offsetof(struct rudolph0_conn, - nackc)); - struct rudolph0_datapacket *p = rimebuf_dataptr(); - - if(p->h.type == TYPE_NACK && c->state == STATE_SENDER) { - if(p->h.version == c->current.h.version) { - PRINTF("Reseting chunk to %d\n", p->h.chunk); - c->current.h.chunk = p->h.chunk; - } else { - PRINTF("Wrong version, reseting chunk to 0\n"); - c->current.h.chunk = 0; - } - read_new_datapacket(c); - sabc_set_timer(&c->c, SENDING_TIME); - } -} -/*---------------------------------------------------------------------------*/ -static const struct uabc_callbacks uabc = { recv_nack, NULL, NULL }; -static const struct sabc_callbacks sabc = { recv, sent }; -/*---------------------------------------------------------------------------*/ -void -rudolph0_open(struct rudolph0_conn *c, u16_t channel, - const struct rudolph0_callbacks *cb) -{ - sabc_open(&c->c, channel, &sabc); - uabc_open(&c->nackc, channel + 1, &uabc); - c->cb = cb; - c->current.h.version = 0; - c->state = STATE_RECEIVER; -} -/*---------------------------------------------------------------------------*/ -void -rudolph0_close(struct rudolph0_conn *c) -{ - sabc_close(&c->c); - uabc_close(&c->nackc); -} -/*---------------------------------------------------------------------------*/ -void -rudolph0_send(struct rudolph0_conn *c) -{ - c->state = STATE_SENDER; - c->current.h.version++; - c->current.h.chunk = 0; - c->current.h.type = TYPE_DATA; - read_new_datapacket(c); - rimebuf_reference(&c->current, sizeof(struct rudolph0_datapacket)); - sabc_send_stubborn(&c->c, SENDING_TIME); -} -/*---------------------------------------------------------------------------*/ -void -rudolph0_stop(struct rudolph0_conn *c) -{ - sabc_cancel(&c->c); -} -/*---------------------------------------------------------------------------*/ -int -rudolph0_version(struct rudolph0_conn *c) -{ - return c->current.h.version; -} -/*---------------------------------------------------------------------------*/ -void -rudolph0_set_version(struct rudolph0_conn *c, int version) -{ - c->current.h.version = version; -} -/*---------------------------------------------------------------------------*/ diff --git a/apps/rudolph/rudolph0.h b/apps/rudolph/rudolph0.h deleted file mode 100644 index 8d6f522fa..000000000 --- a/apps/rudolph/rudolph0.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright (c) 2007, Swedish Institute of Computer Science. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of the Institute nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * This file is part of the Contiki operating system. - * - * $Id: rudolph0.h,v 1.3 2007/03/22 23:54:40 adamdunkels Exp $ - */ - -/** - * \file - * A brief description of what this file is. - * \author - * Adam Dunkels - */ - -#ifndef __RUDOLPH0_H__ -#define __RUDOLPH0_H__ - -#include "net/rime.h" -#include "net/rime/sabc.h" -#include "net/rime/uabc.h" -#include "contiki-net.h" - -struct rudolph0_conn; - -enum { - RUDOLPH0_FLAG_NONE, - RUDOLPH0_FLAG_NEWFILE, - RUDOLPH0_FLAG_LASTCHUNK, -}; - -struct rudolph0_callbacks { - void (* write_chunk)(struct rudolph0_conn *c, int offset, int flag, - char *data, int len); - int (* read_chunk)(struct rudolph0_conn *c, int offset, char *to, - int maxsize); -}; - -#define RUDOLPH0_DATASIZE 64 - -struct rudolph0_hdr { - u8_t type; - u8_t version; - u16_t chunk; -}; - -struct rudolph0_datapacket { - struct rudolph0_hdr h; - u8_t datalen; - u8_t data[RUDOLPH0_DATASIZE]; -}; - -struct rudolph0_conn { - struct sabc_conn c; - struct uabc_conn nackc; - const struct rudolph0_callbacks *cb; - u8_t state; - struct rudolph0_datapacket current; -}; - -void rudolph0_open(struct rudolph0_conn *c, u16_t channel, - const struct rudolph0_callbacks *cb); -void rudolph0_close(struct rudolph0_conn *c); -void rudolph0_send(struct rudolph0_conn *c); -void rudolph0_stop(struct rudolph0_conn *c); - -void rudolph0_set_version(struct rudolph0_conn *c, int version); -int rudolph0_version(struct rudolph0_conn *c); - -#endif /* __RUDOLPH0_H__ */ diff --git a/apps/rudolph/rudolph1.c b/apps/rudolph/rudolph1.c deleted file mode 100644 index 92902db3e..000000000 --- a/apps/rudolph/rudolph1.c +++ /dev/null @@ -1,292 +0,0 @@ -/* - * Copyright (c) 2007, Swedish Institute of Computer Science. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of the Institute nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * This file is part of the Contiki operating system. - * - * $Id: rudolph1.c,v 1.3 2007/03/23 10:46:56 adamdunkels Exp $ - */ - -/** - * \file - * Rudolph1: a simple block data flooding protocol - * \author - * Adam Dunkels - */ - -#include "net/rime.h" -#include "rudolph1.h" -#include "cfs/cfs.h" - -#include /* for offsetof */ - -#define DATA_INTERVAL CLOCK_SECOND * 2 -#define TRICKLE_INTERVAL TRICKLE_SECOND -#define NACK_TIMEOUT CLOCK_SECOND - -struct rudolph1_hdr { - u8_t type; - u8_t version; - u16_t chunk; -}; - -#define RUDOLPH1_DATASIZE 32 - -struct rudolph1_datapacket { - struct rudolph1_hdr h; - u8_t datalen; - u8_t data[RUDOLPH1_DATASIZE]; -}; - -enum { - TYPE_DATA, - TYPE_NACK, -}; - -#define DEBUG 0 -#if DEBUG -#include -#define PRINTF(...) printf(__VA_ARGS__) -#else -#define PRINTF(...) -#endif - -#define LT(a, b) ((signed char)((a) - (b)) < 0) - -/*---------------------------------------------------------------------------*/ -static int -read_data(struct rudolph1_conn *c, char *dataptr, int chunk) -{ - int len = 0; - - if(c->cb->read_chunk) { - len = c->cb->read_chunk(c, chunk * RUDOLPH1_DATASIZE, - dataptr, RUDOLPH1_DATASIZE); - } - - /* cfs_seek(c->cfs_fd, chunk * RUDOLPH1_DATASIZE); - len = cfs_read(c->cfs_fd, dataptr, RUDOLPH1_DATASIZE);*/ - return len; -} -/*---------------------------------------------------------------------------*/ -static int -format_data(struct rudolph1_conn *c, int chunk) -{ - struct rudolph1_datapacket *p; - - rimebuf_clear(); - p = rimebuf_dataptr(); - p->h.type = TYPE_DATA; - p->h.version = c->version; - p->h.chunk = chunk; - p->datalen = read_data(c, p->data, chunk); - rimebuf_set_datalen(sizeof(struct rudolph1_datapacket) - - (RUDOLPH1_DATASIZE - p->datalen)); - - return p->datalen; -} -/*---------------------------------------------------------------------------*/ -static void -write_data(struct rudolph1_conn *c, int chunk, u8_t *data, int datalen) -{ - if(chunk == 0) { - c->cb->write_chunk(c, 0, RUDOLPH1_FLAG_NEWFILE, data, 0); - } - - - /* cfs_seek(c->cfs_fd, chunk * RUDOLPH1_DATASIZE); - cfs_write(c->cfs_fd, data, datalen);*/ - if(datalen < RUDOLPH1_DATASIZE) { - PRINTF("%d: get %d bytes, file complete\n", - rimeaddr_node_addr.u16, datalen); - /* c->cb->received_file(c, c->cfs_fd);*/ - c->cb->write_chunk(c, chunk * RUDOLPH1_DATASIZE, - RUDOLPH1_FLAG_LASTCHUNK, data, datalen); - } else { - c->cb->write_chunk(c, chunk * RUDOLPH1_DATASIZE, - RUDOLPH1_FLAG_NONE, data, datalen); - } -} -/*---------------------------------------------------------------------------*/ -static void -send_nack(struct rudolph1_conn *c) -{ - struct rudolph1_hdr *hdr; - rimebuf_clear(); - rimebuf_hdralloc(sizeof(struct rudolph1_hdr)); - hdr = rimebuf_hdrptr(); - - hdr->type = TYPE_NACK; - hdr->version = c->version; - hdr->chunk = c->chunk; - - PRINTF("Sending nack for %d:%d\n", hdr->version, hdr->chunk); - uabc_send(&c->uabc, CLOCK_SECOND / 4); -} -/*---------------------------------------------------------------------------*/ -static void -handle_data(struct rudolph1_conn *c, struct rudolph1_datapacket *p) -{ - if(LT(c->version, p->h.version)) { - PRINTF("rudolph1 new version %d\n", p->h.version); - /* c->cfs_fd = c->cb->new_file(c);*/ - c->version = p->h.version; - c->chunk = 1; /* Next chunk is 1. */ - /* if(c->cfs_fd != -1) {*/ - if(p->h.chunk != 0) { - send_nack(c); - } else { - write_data(c, 0, p->data, p->datalen); - } - /* }*/ - } else if(p->h.version == c->version) { - /* if(c->cfs_fd != -1) {*/ - if(p->h.chunk == c->chunk) { - PRINTF("%d: received chunk %d\n", - rimeaddr_node_addr.u16, p->h.chunk); - write_data(c, p->h.chunk, p->data, p->datalen); - c->chunk++; - /* cfs_seek(c->cfs_fd, c->chunk * RUDOLPH1_DATASIZE); - cfs_write(c->cfs_fd, p->data, p->datalen); - c->chunk++; - if(p->datalen < RUDOLPH1_DATASIZE) { - c->cb->received_file(c, c->cfs_fd); - }*/ - } else if(p->h.chunk > c->chunk) { - PRINTF("%d: received chunk %d > %d, sending NACK\n", - rimeaddr_node_addr.u16, - p->h.chunk, c->chunk); - send_nack(c); - } -/* } */ - } else { /* p->h.version < c->current.h.version */ - /* Ignore packets with old version */ - } - -} -/*---------------------------------------------------------------------------*/ -static void -recv_trickle(struct trickle_conn *trickle) -{ - struct rudolph1_conn *c = (struct rudolph1_conn *)trickle; - struct rudolph1_datapacket *p = rimebuf_dataptr(); - - /* if(rand() & 1) { - return; - }*/ - - if(p->h.type == TYPE_DATA) { - handle_data(c, p); - } -} -/*---------------------------------------------------------------------------*/ -static void -recv_uabc(struct uabc_conn *uabc) -{ - struct rudolph1_conn *c = (struct rudolph1_conn *) - ((char *)uabc - offsetof(struct rudolph1_conn, uabc)); - struct rudolph1_datapacket *p = rimebuf_dataptr(); - - /* if(rand() & 1) { - return; - }*/ - - c->nacks++; - - if(p->h.type == TYPE_NACK) { - if(p->h.version == c->version) { - if(p->h.chunk < c->chunk) { - format_data(c, p->h.chunk); - uabc_send(&c->uabc, NACK_TIMEOUT); - } - } else if(LT(p->h.version, c->version)) { - format_data(c, 0); - uabc_send(&c->uabc, NACK_TIMEOUT); - } - } else if(p->h.type == TYPE_DATA) { - handle_data(c, p); - } -} -/*---------------------------------------------------------------------------*/ -static void -send_next_packet(void *ptr) -{ - struct rudolph1_conn *c = ptr; - int len; - if(c->nacks == 0) { - c->chunk++; - len = format_data(c, c->chunk); - trickle_send(&c->trickle, c->trickle_interval); - if(len == RUDOLPH1_DATASIZE) { - ctimer_set(&c->t, DATA_INTERVAL, send_next_packet, c); - } - } else { - ctimer_set(&c->t, DATA_INTERVAL, send_next_packet, c); - } - c->nacks = 0; -} -/*---------------------------------------------------------------------------*/ -static const struct uabc_callbacks uabc = { recv_uabc, NULL, NULL }; -static const struct trickle_callbacks trickle = { recv_trickle }; -/*---------------------------------------------------------------------------*/ -void -rudolph1_open(struct rudolph1_conn *c, u16_t channel, - const struct rudolph1_callbacks *cb) -{ - trickle_open(&c->trickle, channel, &trickle); - uabc_open(&c->uabc, channel + 1, &uabc); - c->cb = cb; - c->version = 0; -} -/*---------------------------------------------------------------------------*/ -void -rudolph1_close(struct rudolph1_conn *c) -{ - trickle_close(&c->trickle); - uabc_close(&c->uabc); -} -/*---------------------------------------------------------------------------*/ -void -rudolph1_send(struct rudolph1_conn *c) -{ - /* c->cfs_fd = cfs_fd;*/ - c->version++; - c->chunk = 0; - c->trickle_interval = TRICKLE_INTERVAL; - format_data(c, 0); - trickle_send(&c->trickle, c->trickle_interval); - ctimer_set(&c->t, DATA_INTERVAL, send_next_packet, c); -} -/*---------------------------------------------------------------------------*/ -void -rudolph1_stop(struct rudolph1_conn *c) -{ - /* XXX */ - ctimer_stop(&c->t); - printf("rudolph1_stop: not implemented\n"); -} -/*---------------------------------------------------------------------------*/ diff --git a/apps/rudolph/rudolph1.h b/apps/rudolph/rudolph1.h deleted file mode 100644 index d6e1486f5..000000000 --- a/apps/rudolph/rudolph1.h +++ /dev/null @@ -1,81 +0,0 @@ -/* - * Copyright (c) 2007, Swedish Institute of Computer Science. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of the Institute nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * This file is part of the Contiki operating system. - * - * $Id: rudolph1.h,v 1.2 2007/03/22 23:54:40 adamdunkels Exp $ - */ - -/** - * \file - * A brief description of what this file is. - * \author - * Adam Dunkels - */ - -#ifndef __RUDOLPH1_H__ -#define __RUDOLPH1_H__ - -#include "net/rime.h" -#include "net/rime/trickle.h" -#include "net/rime/uabc.h" -#include "contiki-net.h" - -struct rudolph1_conn; - -enum { - RUDOLPH1_FLAG_NONE, - RUDOLPH1_FLAG_NEWFILE, - RUDOLPH1_FLAG_LASTCHUNK, -}; - -struct rudolph1_callbacks { - void (* write_chunk)(struct rudolph1_conn *c, int offset, int flag, - char *data, int len); - int (* read_chunk)(struct rudolph1_conn *c, int offset, char *to, - int maxsize); -}; - -struct rudolph1_conn { - struct trickle_conn trickle; - struct uabc_conn uabc; - const struct rudolph1_callbacks *cb; - struct ctimer t; - u16_t chunk; - u8_t version; - u8_t trickle_interval; - u8_t nacks; -}; - -void rudolph1_open(struct rudolph1_conn *c, u16_t channel, - const struct rudolph1_callbacks *cb); -void rudolph1_close(struct rudolph1_conn *c); -void rudolph1_send(struct rudolph1_conn *c); -void rudolph1_stop(struct rudolph1_conn *c); - -#endif /* __RUDOLPH1_H__ */