mirror of
https://github.com/oliverschmidt/contiki.git
synced 2024-08-26 10:28:58 +00:00
allows a program to register an 8-bit service ID that gets disseminated to the entire network, as long as a servreg-hack daemon is running on all neighbors. Other nodes can look up the service ID to figure out what nodes in the network offer this service. This is officially labeled as a "hack" so that we don't get too comfy with it; this hack is not the future of service discovery and advertisement in Contiki.
370 lines
11 KiB
C
370 lines
11 KiB
C
/** \addtogroup servreghack
|
|
* @{ */
|
|
|
|
/*
|
|
* Copyright (c) 2010, 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: servreg-hack.c,v 1.1 2010/06/15 19:00:28 adamdunkels Exp $
|
|
*/
|
|
|
|
/**
|
|
* \file
|
|
* Implementation of the servreg-hack application
|
|
* \author
|
|
* Adam Dunkels <adam@sics.se>
|
|
*/
|
|
|
|
#include "contiki.h"
|
|
#include "contiki-lib.h"
|
|
#include "contiki-net.h"
|
|
|
|
#include "net/uip.h"
|
|
|
|
#include "net/uip-ds6.h"
|
|
|
|
#include "servreg-hack.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
struct servreg_hack_registration {
|
|
struct servreg_hack_registration *next;
|
|
|
|
struct timer timer;
|
|
uip_ipaddr_t addr;
|
|
servreg_hack_id_t id;
|
|
uint8_t seqno;
|
|
};
|
|
|
|
|
|
#define MAX_REGISTRATIONS 16
|
|
|
|
LIST(others_services);
|
|
LIST(own_services);
|
|
|
|
MEMB(registrations, struct servreg_hack_registration, MAX_REGISTRATIONS);
|
|
|
|
PROCESS(servreg_hack_process, "Service regstry hack");
|
|
|
|
#define PERIOD_TIME 120 * CLOCK_SECOND
|
|
|
|
#define NEW_REG_TIME 10 * CLOCK_SECOND
|
|
|
|
#define MAX_BUFSIZE 2 + 80
|
|
|
|
#define UDP_PORT 61616
|
|
|
|
#define LIFETIME 10 * 60 * CLOCK_SECOND
|
|
|
|
#define SEQNO_LT(a, b) ((signed char)((a) - (b)) < 0)
|
|
|
|
static struct etimer sendtimer;
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Go through the list of registrations and remove those that are too
|
|
old. */
|
|
static void
|
|
purge_registrations(void)
|
|
{
|
|
struct servreg_hack_registration *t;
|
|
for(t = list_head(others_services);
|
|
t != NULL;
|
|
t = list_item_next(t)) {
|
|
if(timer_expired(&t->timer)) {
|
|
list_remove(others_services, t);
|
|
memb_free(®istrations, t);
|
|
t = list_head(others_services);
|
|
}
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
servreg_hack_init(void)
|
|
{
|
|
list_init(others_services);
|
|
list_init(own_services);
|
|
memb_init(®istrations);
|
|
|
|
process_start(&servreg_hack_process, NULL);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
servreg_hack_register(servreg_hack_id_t id)
|
|
{
|
|
servreg_hack_item_t *t;
|
|
struct servreg_hack_registration *r;
|
|
/* Walk through list, see if we already have a service ID
|
|
registered. If not, allocate a new registration and put it on our
|
|
list. If we cannot allocate a service registration, we reuse one
|
|
from the service registrations made by others. */
|
|
|
|
for(t = list_head(own_services);
|
|
t != NULL;
|
|
t = list_item_next(t)) {
|
|
if(servreg_hack_item_id(t) == id) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
r = memb_alloc(®istrations);
|
|
if(r == NULL) {
|
|
printf("servreg_hack_register: error, could not allocate memory, should reclaim another registration but this has not been implemented yet.\n");
|
|
return;
|
|
}
|
|
r->id = id;
|
|
r->seqno = 1;
|
|
list_push(own_services, r);
|
|
|
|
|
|
PROCESS_CONTEXT_BEGIN(&servreg_hack_process);
|
|
etimer_set(&sendtimer, random_rand() % (NEW_REG_TIME));
|
|
PROCESS_CONTEXT_END(&servreg_hack_process);
|
|
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
servreg_hack_item_t *
|
|
servreg_hack_list_head(void)
|
|
{
|
|
purge_registrations();
|
|
return list_head(others_services);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
servreg_hack_id_t
|
|
servreg_hack_item_id(servreg_hack_item_t *item)
|
|
{
|
|
return ((struct servreg_hack_registration *)item)->id;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
uip_ipaddr_t *
|
|
servreg_hack_item_address(servreg_hack_item_t *item)
|
|
{
|
|
return &((struct servreg_hack_registration *)item)->addr;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
uip_ipaddr_t *
|
|
servreg_hack_lookup(servreg_hack_id_t id)
|
|
{
|
|
servreg_hack_item_t *t;
|
|
|
|
purge_registrations();
|
|
|
|
for(t = servreg_hack_list_head(); t != NULL; t = list_item_next(t)) {
|
|
if(servreg_hack_item_id(t) == id) {
|
|
return servreg_hack_item_address(t);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
handle_incoming_reg(const uip_ipaddr_t *owner, servreg_hack_id_t id, uint8_t seqno)
|
|
{
|
|
servreg_hack_item_t *t;
|
|
struct servreg_hack_registration *r;
|
|
|
|
/* Walk through list, see if we already have a service ID
|
|
registered. If so, we do different things depending on the seqno
|
|
of the update: if the seqno is older than what we have, we
|
|
discard the incoming registration. If the seqno is newer than
|
|
what we have, we reset the lifetime timer of the current
|
|
registration.
|
|
|
|
If we did not have the service registered already, we allocate a
|
|
new registration and put it on our list. If we cannot allocate a
|
|
service registration, we discard the incoming registration (for
|
|
now - we might later choose to discard the oldest registration
|
|
that we have). */
|
|
|
|
/* printf("Handle incoming reg id %d seqno %d\n", id, seqno);*/
|
|
|
|
for(t = servreg_hack_list_head();
|
|
t != NULL;
|
|
t = list_item_next(t)) {
|
|
if(servreg_hack_item_id(t) == id) {
|
|
r = t;
|
|
if(SEQNO_LT(r->seqno, seqno)) {
|
|
r->seqno = seqno;
|
|
timer_set(&r->timer, LIFETIME);
|
|
|
|
/* Put item first on list, so that subsequent lookups will
|
|
find this one. */
|
|
list_remove(others_services, r);
|
|
list_push(others_services, r);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
r = memb_alloc(®istrations);
|
|
if(r == NULL) {
|
|
printf("servreg_hack_register: error, could not allocate memory, should reclaim another registration but this has not been implemented yet.\n");
|
|
return;
|
|
}
|
|
r->id = id;
|
|
r->seqno = 1;
|
|
uip_ipaddr_copy(&r->addr, owner);
|
|
timer_set(&r->timer, LIFETIME);
|
|
list_add(others_services, r);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/*
|
|
* The structure of UDP messages:
|
|
*
|
|
* +-------------------+-------------------+
|
|
* | Numregs (1 byte) | Flags (1 byte) |
|
|
* +-------------------+-------------------+-------------------+
|
|
* | IP addr (16 bytes)| 3 regs (3 bytes) | Seqno (1 byte) |
|
|
* +-------------------+-------------------+-------------------+
|
|
* | IP addr (16 bytes)| 3 regs (3 bytes) | Seqno (1 byte) |
|
|
* +-------------------+-------------------+-------------------+
|
|
* | ... | ... | ... |
|
|
* +-------------------+-------------------+-------------------+
|
|
*/
|
|
|
|
#define MSG_NUMREGS_OFFSET 0
|
|
#define MSG_FLAGS_OFFSET 1
|
|
#define MSG_ADDRS_OFFSET 2
|
|
|
|
#define MSG_IPADDR_SUBOFFSET 0
|
|
#define MSG_REGS_SUBOFFSET 16
|
|
#define MSG_SEQNO_SUBOFFSET 19
|
|
|
|
#define MSG_ADDRS_LEN 20
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
send_udp_packet(struct uip_udp_conn *conn)
|
|
{
|
|
int numregs;
|
|
uint8_t buf[MAX_BUFSIZE];
|
|
int bufptr;
|
|
servreg_hack_item_t *t;
|
|
uip_ds6_addr_t *addr;
|
|
|
|
addr = uip_ds6_get_global(-1);
|
|
|
|
buf[MSG_FLAGS_OFFSET] = 0;
|
|
|
|
numregs = 0;
|
|
bufptr = MSG_ADDRS_OFFSET;
|
|
|
|
|
|
if(addr != NULL) {
|
|
for(t = list_head(own_services);
|
|
(bufptr + MSG_ADDRS_LEN <= MAX_BUFSIZE) && t != NULL;
|
|
t = list_item_next(t)) {
|
|
|
|
uip_ipaddr_copy((uip_ipaddr_t *)&buf[bufptr + MSG_IPADDR_SUBOFFSET],
|
|
&addr->ipaddr);
|
|
buf[bufptr + MSG_REGS_SUBOFFSET] =
|
|
servreg_hack_item_id(t);
|
|
buf[bufptr + MSG_REGS_SUBOFFSET + 1] =
|
|
buf[bufptr + MSG_REGS_SUBOFFSET + 2] = 0;
|
|
buf[bufptr + MSG_SEQNO_SUBOFFSET] = ((struct servreg_hack_registration *)t)->seqno;
|
|
|
|
bufptr += MSG_ADDRS_LEN;
|
|
++numregs;
|
|
}
|
|
}
|
|
|
|
for(t = servreg_hack_list_head();
|
|
(bufptr + MSG_ADDRS_LEN <= MAX_BUFSIZE) && t != NULL;
|
|
t = list_item_next(t)) {
|
|
uip_ipaddr_copy((uip_ipaddr_t *)&buf[bufptr + MSG_IPADDR_SUBOFFSET],
|
|
servreg_hack_item_address(t));
|
|
buf[bufptr + MSG_REGS_SUBOFFSET] =
|
|
servreg_hack_item_id(t);
|
|
buf[bufptr + MSG_REGS_SUBOFFSET + 1] =
|
|
buf[bufptr + MSG_REGS_SUBOFFSET + 2] = 0;
|
|
buf[bufptr + MSG_SEQNO_SUBOFFSET] = ((struct servreg_hack_registration *)t)->seqno;
|
|
|
|
bufptr += MSG_ADDRS_LEN;
|
|
++numregs;
|
|
}
|
|
/* printf("send_udp_packet numregs %d\n", numregs);*/
|
|
buf[MSG_NUMREGS_OFFSET] = numregs;
|
|
|
|
if(numregs > 0) {
|
|
/* printf("Sending buffer len %d\n", bufptr);*/
|
|
uip_udp_packet_send(conn, buf, bufptr);
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
parse_incoming_packet(const u8_t *buf, int len)
|
|
{
|
|
int numregs;
|
|
int flags;
|
|
int i;
|
|
int bufptr;
|
|
|
|
numregs = buf[MSG_NUMREGS_OFFSET];
|
|
flags = buf[MSG_FLAGS_OFFSET];
|
|
|
|
/* printf("Numregs %d flags %d\n", numregs, flags);*/
|
|
|
|
bufptr = MSG_ADDRS_OFFSET;
|
|
for(i = 0; i < numregs; ++i) {
|
|
handle_incoming_reg((uip_ipaddr_t *)&buf[bufptr + MSG_IPADDR_SUBOFFSET],
|
|
buf[bufptr + MSG_REGS_SUBOFFSET],
|
|
buf[bufptr + MSG_SEQNO_SUBOFFSET]);
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
PROCESS_THREAD(servreg_hack_process, ev, data)
|
|
{
|
|
static struct etimer periodic;
|
|
static struct uip_udp_conn *outconn, *inconn;
|
|
PROCESS_BEGIN();
|
|
|
|
/* Create outbound UDP connection. */
|
|
outconn = udp_broadcast_new(HTONS(UDP_PORT), NULL);
|
|
udp_bind(outconn, HTONS(UDP_PORT));
|
|
|
|
/* Create inbound UDP connection. */
|
|
inconn = udp_new(NULL, HTONS(UDP_PORT), NULL);
|
|
udp_bind(inconn, HTONS(UDP_PORT));
|
|
|
|
etimer_set(&periodic, PERIOD_TIME);
|
|
etimer_set(&sendtimer, random_rand() % (PERIOD_TIME));
|
|
while(1) {
|
|
PROCESS_WAIT_EVENT();
|
|
if(ev == PROCESS_EVENT_TIMER && data == &periodic) {
|
|
etimer_reset(&periodic);
|
|
etimer_set(&sendtimer, random_rand() % (PERIOD_TIME));
|
|
} else if(ev == PROCESS_EVENT_TIMER && data == &sendtimer) {
|
|
send_udp_packet(outconn);
|
|
} else if(ev == tcpip_event) {
|
|
parse_incoming_packet(uip_appdata, uip_datalen());
|
|
}
|
|
}
|
|
PROCESS_END();
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|