Subversion Repositories openrisc

/**

 * @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 */