mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-07-16 10:06:17 +02:00
218 lines
6.9 KiB
C
218 lines
6.9 KiB
C
/**
|
|
* @file
|
|
* Loop Interface
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2001-2004 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"
|
|
|
|
#if LWIP_HAVE_LOOPIF
|
|
|
|
#include "netif/loopif.h"
|
|
#include "lwip/pbuf.h"
|
|
#include "lwip/snmp.h"
|
|
|
|
#include <string.h>
|
|
|
|
#if !LWIP_LOOPIF_MULTITHREADING
|
|
|
|
#include "lwip/sys.h"
|
|
#include "lwip/mem.h"
|
|
|
|
/* helper struct for the linked list of pbufs */
|
|
struct loopif_private {
|
|
struct pbuf *first;
|
|
struct pbuf *last;
|
|
};
|
|
|
|
/**
|
|
* Call loopif_poll() in the main loop of your application. This is to prevent
|
|
* reentering non-reentrant functions like tcp_input(). Packets passed to
|
|
* loopif_output() are put on a list that is passed to netif->input() by
|
|
* loopif_poll().
|
|
*
|
|
* @param netif the lwip network interface structure for this loopif
|
|
*/
|
|
void
|
|
loopif_poll(struct netif *netif)
|
|
{
|
|
SYS_ARCH_DECL_PROTECT(lev);
|
|
struct pbuf *in, *in_end;
|
|
struct loopif_private *priv = (struct loopif_private*)netif->state;
|
|
|
|
LWIP_ERROR("priv != NULL", (priv != NULL), return;);
|
|
|
|
do {
|
|
/* Get a packet from the list. With SYS_LIGHTWEIGHT_PROT=1, this is protected */
|
|
SYS_ARCH_PROTECT(lev);
|
|
in = priv->first;
|
|
if(in) {
|
|
in_end = in;
|
|
while(in_end->len != in_end->tot_len) {
|
|
LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL);
|
|
in_end = in_end->next;
|
|
}
|
|
/* 'in_end' now points to the last pbuf from 'in' */
|
|
if(in_end == priv->last) {
|
|
/* this was the last pbuf in the list */
|
|
priv->first = priv->last = NULL;
|
|
} else {
|
|
/* pop the pbuf off the list */
|
|
priv->first = in_end->next;
|
|
LWIP_ASSERT("should not be null since first != last!", priv->first != NULL);
|
|
}
|
|
}
|
|
SYS_ARCH_UNPROTECT(lev);
|
|
|
|
if(in != NULL) {
|
|
if(in_end->next != NULL) {
|
|
/* De-queue the pbuf from its successors on the 'priv' list. */
|
|
in_end->next = NULL;
|
|
}
|
|
if(netif->input(in, netif) != ERR_OK) {
|
|
pbuf_free(in);
|
|
}
|
|
/* Don't reference the packet any more! */
|
|
in = NULL;
|
|
in_end = NULL;
|
|
}
|
|
/* go on while there is a packet on the list */
|
|
} while(priv->first != NULL);
|
|
}
|
|
#endif /* LWIP_LOOPIF_MULTITHREADING */
|
|
|
|
/**
|
|
* Send an IP packet over the loopback interface.
|
|
* The pbuf is simply copied and handed back to netif->input.
|
|
* In multithreaded mode, this is done directly since netif->input must put
|
|
* the packet on a queue.
|
|
* In callback mode, the packet is put on an internal queue and is fed to
|
|
* netif->input by loopif_poll().
|
|
*
|
|
* @param netif the lwip network interface structure for this loopif
|
|
* @param p the (IP) packet to 'send'
|
|
* @param ipaddr the ip address to send the packet to (not used for loopif)
|
|
* @return ERR_OK if the packet has been sent
|
|
* ERR_MEM if the pbuf used to copy the packet couldn't be allocated
|
|
*/
|
|
static err_t
|
|
loopif_output(struct netif *netif, struct pbuf *p,
|
|
struct ip_addr *ipaddr)
|
|
{
|
|
#if !LWIP_LOOPIF_MULTITHREADING
|
|
SYS_ARCH_DECL_PROTECT(lev);
|
|
struct loopif_private *priv;
|
|
struct pbuf *last;
|
|
#endif /* LWIP_LOOPIF_MULTITHREADING */
|
|
struct pbuf *r;
|
|
err_t err;
|
|
|
|
LWIP_UNUSED_ARG(ipaddr);
|
|
|
|
/* Allocate a new pbuf */
|
|
r = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
|
|
if (r == NULL) {
|
|
return ERR_MEM;
|
|
}
|
|
|
|
/* Copy the whole pbuf queue p into the single pbuf r */
|
|
if ((err = pbuf_copy(r, p)) != ERR_OK) {
|
|
pbuf_free(r);
|
|
r = NULL;
|
|
return err;
|
|
}
|
|
|
|
#if LWIP_LOOPIF_MULTITHREADING
|
|
/* Multithreading environment, netif->input() is supposed to put the packet
|
|
into a mailbox, so we can safely call it here without risking to re-enter
|
|
functions that are not reentrant (TCP!!!) */
|
|
if(netif->input(r, netif) != ERR_OK) {
|
|
pbuf_free(r);
|
|
r = NULL;
|
|
}
|
|
#else /* LWIP_LOOPIF_MULTITHREADING */
|
|
/* Raw API without threads: put the packet on a linked list which gets emptied
|
|
through calling loopif_poll(). */
|
|
priv = (struct loopif_private*)netif->state;
|
|
|
|
/* let last point to the last pbuf in chain r */
|
|
for (last = r; last->next != NULL; last = last->next);
|
|
SYS_ARCH_PROTECT(lev);
|
|
if(priv->first != NULL) {
|
|
LWIP_ASSERT("if first != NULL, last must also be != NULL", priv->last != NULL);
|
|
priv->last->next = r;
|
|
priv->last = last;
|
|
} else {
|
|
priv->first = r;
|
|
priv->last = last;
|
|
}
|
|
SYS_ARCH_UNPROTECT(lev);
|
|
#endif /* LWIP_LOOPIF_MULTITHREADING */
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
/**
|
|
* Initialize a lwip network interface structure for a loopback interface
|
|
*
|
|
* @param netif the lwip network interface structure for this loopif
|
|
* @return ERR_OK if the loopif is initialized
|
|
* ERR_MEM if private data couldn't be allocated
|
|
*/
|
|
err_t
|
|
loopif_init(struct netif *netif)
|
|
{
|
|
#if !LWIP_LOOPIF_MULTITHREADING
|
|
struct loopif_private *priv;
|
|
|
|
priv = (struct loopif_private*)mem_malloc(sizeof(struct loopif_private));
|
|
if(priv == NULL)
|
|
return ERR_MEM;
|
|
priv->first = priv->last = NULL;
|
|
netif->state = priv;
|
|
#endif /* LWIP_LOOPIF_MULTITHREADING */
|
|
|
|
/* initialize the snmp variables and counters inside the struct netif
|
|
* ifSpeed: no assumption can be made!
|
|
*/
|
|
NETIF_INIT_SNMP(netif, snmp_ifType_softwareLoopback, 0);
|
|
|
|
netif->name[0] = 'l';
|
|
netif->name[1] = 'o';
|
|
netif->output = loopif_output;
|
|
return ERR_OK;
|
|
}
|
|
|
|
#endif /* LWIP_HAVE_LOOPIF */
|