/* * 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"#include "lwip/sys.h"#include "lwip/memp.h"#include "lwip/pbuf.h"#include "lwip/ip.h"#include "lwip/ip_frag.h"#include "lwip/udp.h"#include "lwip/tcp.h"#include "lwip/tcpip.h"static void (* tcpip_init_done)(void *arg) = NULL;static void *tcpip_init_done_arg;static sys_mbox_t mbox;#if LWIP_TCPstatic int tcpip_tcp_timer_active = 0;static voidtcpip_tcp_timer(void *arg){  (void)arg;  /* call TCP timer handler */  tcp_tmr();  /* timer still needed? */  if (tcp_active_pcbs || tcp_tw_pcbs) {    /* restart timer */    sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL);  } else {    /* disable timer */    tcpip_tcp_timer_active = 0;  }}#if !NO_SYSvoidtcp_timer_needed(void){  /* timer is off but needed again? */  if (!tcpip_tcp_timer_active && (tcp_active_pcbs || tcp_tw_pcbs)) {    /* enable and start timer */    tcpip_tcp_timer_active = 1;    sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL);  }}#endif /* !NO_SYS */#endif /* LWIP_TCP */#if IP_REASSEMBLYstatic voidip_timer(void *data){  LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: ip_reass_tmr()\n"));  ip_reass_tmr();  sys_timeout(1000, ip_timer, NULL);}#endifstatic voidtcpip_thread(void *arg){  struct tcpip_msg *msg;  (void)arg;  ip_init();#if LWIP_UDP    udp_init();#endif#if LWIP_TCP  tcp_init();#endif#if IP_REASSEMBLY  sys_timeout(1000, ip_timer, NULL);#endif  if (tcpip_init_done != NULL) {    tcpip_init_done(tcpip_init_done_arg);  }  while (1) {                          /* MAIN Loop */    sys_mbox_fetch(mbox, (void *)&msg);    switch (msg->type) {    case TCPIP_MSG_API:      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));      api_msg_input(msg->msg.apimsg);      break;    case TCPIP_MSG_INPUT:      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: IP packet %p\n", (void *)msg));      ip_input(msg->msg.inp.p, msg->msg.inp.netif);      break;    case TCPIP_MSG_CALLBACK:      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));      msg->msg.cb.f(msg->msg.cb.ctx);      break;    default:      break;    }    memp_free(MEMP_TCPIP_MSG, msg);  }}err_ttcpip_input(struct pbuf *p, struct netif *inp){  struct tcpip_msg *msg;    msg = memp_malloc(MEMP_TCPIP_MSG);  if (msg == NULL) {    pbuf_free(p);        return ERR_MEM;    }    msg->type = TCPIP_MSG_INPUT;  msg->msg.inp.p = p;  msg->msg.inp.netif = inp;  sys_mbox_post(mbox, msg);  return ERR_OK;}err_ttcpip_callback(void (*f)(void *ctx), void *ctx){  struct tcpip_msg *msg;    msg = memp_malloc(MEMP_TCPIP_MSG);  if (msg == NULL) {    return ERR_MEM;    }    msg->type = TCPIP_MSG_CALLBACK;  msg->msg.cb.f = f;  msg->msg.cb.ctx = ctx;  sys_mbox_post(mbox, msg);  return ERR_OK;}voidtcpip_apimsg(struct api_msg *apimsg){  struct tcpip_msg *msg;  msg = memp_malloc(MEMP_TCPIP_MSG);  if (msg == NULL) {    memp_free(MEMP_API_MSG, apimsg);    return;  }  msg->type = TCPIP_MSG_API;  msg->msg.apimsg = apimsg;  sys_mbox_post(mbox, msg);}voidtcpip_init(void (* initfunc)(void *), void *arg){  tcpip_init_done = initfunc;  tcpip_init_done_arg = arg;  mbox = sys_mbox_new();  sys_thread_new(tcpip_thread, NULL, TCPIP_THREAD_PRIO);}