385 lines
9.7 KiB
C
385 lines
9.7 KiB
C
/*
|
|
* Copyright (c) 2001-2003 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. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 lwIP TCP/IP stack.
|
|
*
|
|
* Author: Adam Dunkels <adam@sics.se>
|
|
*
|
|
*/
|
|
|
|
#include "lwip/opt.h"
|
|
#include "lwip/pbuf.h"
|
|
|
|
#if !NO_SYS
|
|
|
|
#include "lwip/debug.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "lwip/def.h"
|
|
#include "netif/delif.h"
|
|
|
|
#ifdef LWIP_UNIX_LINUX
|
|
#include "netif/tapif.h"
|
|
#else /* LWIP_UNIX_LINUX */
|
|
#include "netif/tunif.h"
|
|
#endif /* LWIP_UNIX_LINUX */
|
|
|
|
#include "lwip/sys.h"
|
|
#include "lwip/timeouts.h"
|
|
|
|
#ifndef DELIF_DEBUG
|
|
#define DELIF_DEBUG LWIP_DBG_OFF
|
|
#endif
|
|
|
|
#define DELIF_INPUT_DROPRATE 0.1
|
|
#define DELIF_OUTPUT_DROPRATE 0.1
|
|
|
|
#define DELIF_INPUT_DELAY 500 /* Miliseconds. */
|
|
#define DELIF_OUTPUT_DELAY 500 /* Miliseconds. */
|
|
|
|
#define DELIF_TIMEOUT 10
|
|
|
|
struct delif {
|
|
err_t (* input)(struct pbuf *p, struct netif *inp);
|
|
struct netif *netif;
|
|
};
|
|
|
|
struct delif_pbuf {
|
|
struct delif_pbuf *next;
|
|
struct pbuf *p;
|
|
ip_addr_t ipaddr;
|
|
unsigned int time;
|
|
};
|
|
|
|
static struct delif_pbuf *input_list = NULL;
|
|
static struct delif_pbuf *output_list = NULL;
|
|
/*-----------------------------------------------------------------------------------*/
|
|
static void
|
|
delif_input_timeout(void *arg)
|
|
{
|
|
struct netif *netif;
|
|
struct delif *delif;
|
|
struct delif_pbuf *dp;
|
|
unsigned int timeout, now;
|
|
|
|
timeout = DELIF_TIMEOUT;
|
|
|
|
netif = (struct netif*)arg;
|
|
delif = (struct delif*)netif->state;
|
|
|
|
/* Check if there is anything on the input list. */
|
|
dp = input_list;
|
|
while (dp != NULL) {
|
|
now = sys_now();
|
|
|
|
if (dp->time <= now) {
|
|
delif->input(dp->p, netif);
|
|
if (dp->next != NULL) {
|
|
if (dp->next->time > now) {
|
|
timeout = dp->next->time - now;
|
|
} else {
|
|
timeout = 0;
|
|
}
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_output_timeout: timeout %u.\n", timeout));
|
|
|
|
}
|
|
input_list = dp->next;
|
|
free(dp);
|
|
dp = input_list;
|
|
} else {
|
|
dp = dp->next;
|
|
}
|
|
}
|
|
|
|
sys_timeout(timeout, delif_input_timeout, arg);
|
|
}
|
|
/*-----------------------------------------------------------------------------------*/
|
|
static void
|
|
delif_output_timeout(void *arg)
|
|
{
|
|
struct netif *netif;
|
|
struct delif *delif;
|
|
struct delif_pbuf *dp;
|
|
unsigned int timeout, now;
|
|
|
|
timeout = DELIF_TIMEOUT;
|
|
|
|
netif = (struct netif*)arg;
|
|
delif = (struct delif*)netif->state;
|
|
|
|
/* Check if there is anything on the output list. */
|
|
dp = output_list;
|
|
while (dp != NULL) {
|
|
now = sys_now();
|
|
if (dp->time <= now) {
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_output_timeout: now %u dp->time %u\n",
|
|
now, dp->time));
|
|
|
|
#if LWIP_IPV4
|
|
if(!IP_IS_V6_VAL(dp->ipaddr)) {
|
|
delif->netif->output(delif->netif, dp->p, ip_2_ip4(&dp->ipaddr));
|
|
}
|
|
#endif /* LWIP_IPV4 */
|
|
|
|
#if LWIP_IPV6
|
|
if(IP_IS_V6_VAL(dp->ipaddr)) {
|
|
delif->netif->output_ip6(delif->netif, dp->p, ip_2_ip6(&dp->ipaddr));
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
|
|
if (dp->next != NULL) {
|
|
if (dp->next->time > now) {
|
|
timeout = dp->next->time - now;
|
|
} else {
|
|
timeout = 0;
|
|
}
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_output_timeout: timeout %u.\n", timeout));
|
|
|
|
}
|
|
pbuf_free(dp->p);
|
|
|
|
output_list = dp->next;
|
|
free(dp);
|
|
dp = output_list;
|
|
} else {
|
|
dp = dp->next;
|
|
}
|
|
}
|
|
|
|
sys_timeout(timeout, delif_output_timeout, arg);
|
|
}
|
|
/*-----------------------------------------------------------------------------------*/
|
|
static err_t
|
|
delif_output(struct netif *netif, struct pbuf *p, const ip_addr_t *ipaddr)
|
|
{
|
|
struct delif_pbuf *dp, *np;
|
|
char *data;
|
|
|
|
LWIP_UNUSED_ARG(netif);
|
|
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_output\n"));
|
|
|
|
#ifdef DELIF_OUTPUT_DROPRATE
|
|
if (((double)rand()/(double)RAND_MAX) < DELIF_OUTPUT_DROPRATE) {
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_output: Packet dropped\n"));
|
|
return ERR_BUF;
|
|
}
|
|
#endif /* DELIF_OUTPUT_DROPRATE */
|
|
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_output\n"));
|
|
|
|
dp = (struct delif_pbuf*)malloc(sizeof(struct delif_pbuf));
|
|
data = (char*)malloc(p->tot_len);
|
|
|
|
pbuf_copy_partial(p, data, p->tot_len, 0);
|
|
|
|
dp->p = pbuf_alloc(PBUF_LINK, 0, PBUF_ROM);
|
|
dp->p->payload = data;
|
|
dp->p->len = p->tot_len;
|
|
dp->p->tot_len = p->tot_len;
|
|
dp->ipaddr = *ipaddr;
|
|
dp->time = sys_now() + DELIF_OUTPUT_DELAY;
|
|
dp->next = NULL;
|
|
if (output_list == NULL) {
|
|
output_list = dp;
|
|
} else {
|
|
for(np = output_list; np->next != NULL; np = np->next);
|
|
np->next = dp;
|
|
}
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
#if LWIP_IPV4
|
|
static err_t
|
|
delif_output4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr)
|
|
{
|
|
ip_addr_t ip;
|
|
if (ipaddr != NULL) {
|
|
ip_addr_copy_from_ip4(ip, *ipaddr);
|
|
} else {
|
|
ip = *IP_ADDR_ANY;
|
|
}
|
|
return delif_output(netif, p, &ip);
|
|
}
|
|
#endif /* LWIP_IPV4 */
|
|
|
|
#if LWIP_IPV6
|
|
static err_t
|
|
delif_output6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr)
|
|
{
|
|
ip_addr_t ip;
|
|
if (ipaddr != NULL) {
|
|
ip_addr_copy_from_ip6(ip, *ipaddr);
|
|
} else {
|
|
ip = *IP6_ADDR_ANY;
|
|
}
|
|
return delif_output(netif, p, &ip);
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
/*-----------------------------------------------------------------------------------*/
|
|
static err_t
|
|
delif_input(struct pbuf *p, struct netif *inp)
|
|
{
|
|
struct delif_pbuf *dp, *np;
|
|
|
|
LWIP_UNUSED_ARG(inp);
|
|
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_input\n"));
|
|
#ifdef DELIF_INPUT_DROPRATE
|
|
if (((double)rand()/(double)RAND_MAX) < DELIF_INPUT_DROPRATE) {
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_input: Packet dropped\n"));
|
|
pbuf_free(p);
|
|
return ERR_OK;
|
|
}
|
|
#endif /* DELIF_INPUT_DROPRATE */
|
|
|
|
dp = (struct delif_pbuf*)malloc(sizeof(struct delif_pbuf));
|
|
dp->p = p;
|
|
dp->time = sys_now() + DELIF_INPUT_DELAY;
|
|
dp->next = NULL;
|
|
|
|
if (input_list == NULL) {
|
|
input_list = dp;
|
|
} else {
|
|
for(np = input_list; np->next != NULL; np = np->next);
|
|
np->next = dp;
|
|
}
|
|
|
|
return ERR_OK;
|
|
}
|
|
/*-----------------------------------------------------------------------------------*/
|
|
err_t
|
|
delif_init(struct netif *netif)
|
|
{
|
|
struct delif *del;
|
|
|
|
del = (struct delif*)malloc(sizeof(struct delif));
|
|
if (!del) {
|
|
return ERR_MEM;
|
|
}
|
|
netif->state = del;
|
|
netif->name[0] = 'd';
|
|
netif->name[1] = 'e';
|
|
|
|
#if LWIP_IPV4
|
|
netif->output = delif_output4;
|
|
#endif /* LWIP_IPV4 */
|
|
#if LWIP_IPV6
|
|
netif->output_ip6 = delif_output6;
|
|
#endif /* LWIP_IPV6 */
|
|
|
|
del->netif = (struct netif*)malloc(sizeof(struct netif));
|
|
if (!del->netif) {
|
|
free(del);
|
|
return ERR_MEM;
|
|
}
|
|
|
|
#ifdef LWIP_UNIX_LINUX
|
|
tapif_init(del->netif);
|
|
#else /* LWIP_UNIX_LINUX */
|
|
tunif_init(del->netif);
|
|
#endif /* LWIP_UNIX_LINUX */
|
|
|
|
del->input = netif->input;
|
|
del->netif->input = delif_input;
|
|
|
|
sys_timeout(DELIF_TIMEOUT, delif_input_timeout, netif);
|
|
sys_timeout(DELIF_TIMEOUT, delif_output_timeout, netif);
|
|
return ERR_OK;
|
|
}
|
|
/*-----------------------------------------------------------------------------------*/
|
|
static void
|
|
delif_thread(void *arg)
|
|
{
|
|
struct netif *netif = (struct netif*)arg;
|
|
struct delif *del;
|
|
sys_sem_t sem;
|
|
|
|
del = (struct delif*)netif->state;
|
|
#ifdef LWIP_UNIX_LINUX
|
|
tapif_init(del->netif);
|
|
#else /* LWIP_UNIX_LINUX */
|
|
tunif_init(del->netif);
|
|
#endif /* LWIP_UNIX_LINUX */
|
|
|
|
sys_timeout(DELIF_TIMEOUT, delif_input_timeout, netif);
|
|
sys_timeout(DELIF_TIMEOUT, delif_output_timeout, netif);
|
|
|
|
if(sys_sem_new(&sem, 0) != ERR_OK) {
|
|
LWIP_ASSERT("Failed to create semaphore", 0);
|
|
}
|
|
sys_sem_wait(&sem);
|
|
}
|
|
/*-----------------------------------------------------------------------------------*/
|
|
err_t
|
|
delif_init_thread(struct netif *netif)
|
|
{
|
|
struct delif *del;
|
|
|
|
LWIP_DEBUGF(DELIF_DEBUG, ("delif_init_thread\n"));
|
|
|
|
del = (struct delif*)malloc(sizeof(struct delif));
|
|
if (!del) {
|
|
return ERR_MEM;
|
|
}
|
|
|
|
netif->state = del;
|
|
netif->name[0] = 'd';
|
|
netif->name[1] = 'e';
|
|
|
|
del->netif = (struct netif*)malloc(sizeof(struct netif));
|
|
if (!del->netif) {
|
|
free(del);
|
|
return ERR_MEM;
|
|
}
|
|
|
|
#if LWIP_IPV4
|
|
netif->output = delif_output4;
|
|
netif_set_addr(del->netif, netif_ip4_addr(netif), netif_ip4_netmask(netif), netif_ip4_gw(netif));
|
|
#endif /* LWIP_IPV4 */
|
|
|
|
#if LWIP_IPV6
|
|
{
|
|
s8_t i;
|
|
netif->output_ip6 = delif_output6;
|
|
for(i=0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
|
|
netif_ip6_addr_set(del->netif, i, netif_ip6_addr(netif, i));
|
|
}
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
|
|
del->input = netif->input;
|
|
del->netif->input = delif_input;
|
|
|
|
sys_thread_new("delif_thread", delif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
|
|
return ERR_OK;
|
|
}
|
|
/*-----------------------------------------------------------------------------------*/
|
|
|
|
#endif /* !NO_SYS */
|