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