From d9f0c89726878645446bfa260868e37ef4e2954c Mon Sep 17 00:00:00 2001 From: adamdunkels Date: Sun, 25 Mar 2007 11:56:59 +0000 Subject: [PATCH] Moved rudolph{0,1} from apps/ directory into core/net/rime --- core/net/rime/Makefile.rime | 3 +- core/net/rime/rudolph0.c | 231 ++++++++++++++++++++++++++++ core/net/rime/rudolph0.h | 95 ++++++++++++ core/net/rime/rudolph1.c | 292 ++++++++++++++++++++++++++++++++++++ core/net/rime/rudolph1.h | 81 ++++++++++ 5 files changed, 701 insertions(+), 1 deletion(-) create mode 100644 core/net/rime/rudolph0.c create mode 100644 core/net/rime/rudolph0.h create mode 100644 core/net/rime/rudolph1.c create mode 100644 core/net/rime/rudolph1.h diff --git a/core/net/rime/Makefile.rime b/core/net/rime/Makefile.rime index 626d1da3a..f884e967c 100644 --- a/core/net/rime/Makefile.rime +++ b/core/net/rime/Makefile.rime @@ -3,4 +3,5 @@ CONTIKI_SOURCEFILES += rimebuf.c queuebuf.c rimeaddr.c ctimer.c rime.c \ uibc.c mh.c \ mesh.c route.c route-discovery.c \ tree.c neighbor.c \ - trickle.c + trickle.c \ + rudolph0.c rudolph1.c diff --git a/core/net/rime/rudolph0.c b/core/net/rime/rudolph0.c new file mode 100644 index 000000000..ea206c232 --- /dev/null +++ b/core/net/rime/rudolph0.c @@ -0,0 +1,231 @@ +/* + * 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.1 2007/03/25 11:56:59 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/core/net/rime/rudolph0.h b/core/net/rime/rudolph0.h new file mode 100644 index 000000000..2b7bc0b99 --- /dev/null +++ b/core/net/rime/rudolph0.h @@ -0,0 +1,95 @@ +/* + * 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.1 2007/03/25 11:56:59 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/core/net/rime/rudolph1.c b/core/net/rime/rudolph1.c new file mode 100644 index 000000000..d6981cf22 --- /dev/null +++ b/core/net/rime/rudolph1.c @@ -0,0 +1,292 @@ +/* + * 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.1 2007/03/25 11:58:09 adamdunkels Exp $ + */ + +/** + * \file + * Rudolph1: a simple block data flooding protocol + * \author + * Adam Dunkels + */ + +#include "net/rime.h" +#include "net/rime/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/core/net/rime/rudolph1.h b/core/net/rime/rudolph1.h new file mode 100644 index 000000000..ac859247c --- /dev/null +++ b/core/net/rime/rudolph1.h @@ -0,0 +1,81 @@ +/* + * 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.1 2007/03/25 11:58:09 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__ */