tcpip.c File Reference

#include "lwip/opt.h"
#include "lwip/sys.h"
#include "lwip/memp.h"
#include "lwip/mem.h"
#include "lwip/pbuf.h"
#include "lwip/tcpip.h"
#include "lwip/init.h"
#include "netif/etharp.h"
#include "netif/ppp_oe.h"

Include dependency graph for tcpip.c:

Go to the source code of this file.

Functions
static void	tcpip_thread (void *arg)
err_t	tcpip_input (struct pbuf *p, struct netif *inp)
err_t	tcpip_callback_with_block (tcpip_callback_fn function, void *ctx, u8_t block)
void	tcpip_init (tcpip_init_done_fn initfunc, void *arg)
static void	pbuf_free_int (void *p)
err_t	pbuf_free_callback (struct pbuf *p)
err_t	mem_free_callback (void *m)

Variables
static tcpip_init_done_fn	tcpip_init_done
static void *	tcpip_init_done_arg
static sys_mbox_t	mbox

Detailed Description

Sequential API Main thread module

Definition in file tcpip.c.

Function Documentation

mem_free_callback()

err_t mem_free_callback

(

void *

m

)

A simple wrapper function that allows you to free heap memory from interrupt context.

Parameters

m	the heap memory to free

Returns

ERR_OK if callback could be enqueued, an err_t if not

Definition at line 455 of file tcpip.c.

References mem_free(), and tcpip_callback_with_block().

{
  return tcpip_callback_with_block(mem_free, m, 0);
}

Here is the call graph for this function:

pbuf_free_callback()

err_t pbuf_free_callback

(

struct pbuf *

p

)

A simple wrapper function that allows you to free a pbuf from interrupt context.

Parameters

p	The pbuf (chain) to be dereferenced.

Returns

ERR_OK if callback could be enqueued, an err_t if not

Definition at line 442 of file tcpip.c.

References pbuf_free_int(), and tcpip_callback_with_block().

{
  return tcpip_callback_with_block(pbuf_free_int, p, 0);
}

Here is the call graph for this function:

pbuf_free_int()

static void pbuf_free_int ( void *  p )

static

Simple callback function used with tcpip_callback to free a pbuf (pbuf_free has a wrong signature for tcpip_callback)

Parameters

p	The pbuf (chain) to be dereferenced.

Definition at line 429 of file tcpip.c.

References pbuf_free().

Referenced by pbuf_free_callback().

{
  struct pbuf *q = (struct pbuf *)p;
  pbuf_free(q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tcpip_callback_with_block()

err_t tcpip_callback_with_block	(	tcpip_callback_fn	function,
		void *	ctx,
		u8_t	block
	)

Call a specific function in the thread context of tcpip_thread for easy access synchronization. A function called in that way may access lwIP core code without fearing concurrent access.

Parameters

f	the function to call
ctx	parameter passed to f
block	1 to block until the request is posted, 0 to non-blocking mode

Returns

ERR_OK if the function was called, another err_t if not

Definition at line 206 of file tcpip.c.

References tcpip_msg::cb, tcpip_msg::ctx, ERR_MEM, ERR_OK, ERR_VAL, LOCK_TCPIP_CORE, mbox, memp_free(), memp_malloc(), tcpip_msg::msg, NULL, sys_arch_sem_wait(), sys_mbox_post(), sys_mbox_trypost(), sys_mbox_valid(), sys_sem_free(), sys_sem_new(), sys_sem_wait, TCPIP_MSG_CALLBACK, tcpip_msg::type, and UNLOCK_TCPIP_CORE.

Referenced by mem_free_callback(), and pbuf_free_callback().

{
  struct tcpip_msg *msg;

  if (sys_mbox_valid(&mbox)) {
    msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API);
    if (msg == NULL) {
      return ERR_MEM;
    }

    msg->type = TCPIP_MSG_CALLBACK;
    msg->msg.cb.function = function;
    msg->msg.cb.ctx = ctx;
    if (block) {
      sys_mbox_post(&mbox, msg);
    } else {
      if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {
        memp_free(MEMP_TCPIP_MSG_API, msg);
        return ERR_MEM;
      }
    }
    return ERR_OK;
  }
  return ERR_VAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tcpip_init()

void tcpip_init	(	tcpip_init_done_fn	initfunc,
		void *	arg
	)

Initialize this module:

• initialize all sub modules
• start the tcpip_thread

Parameters

initfunc	a function to call when tcpip_thread is running and finished initializing
arg	argument to pass to initfunc

Definition at line 404 of file tcpip.c.

References ERR_OK, LWIP_ASSERT, lwip_init(), mbox, NULL, sys_mbox_new(), sys_mutex_new(), sys_thread_new(), tcpip_init_done, tcpip_init_done_arg, TCPIP_MBOX_SIZE, tcpip_thread(), TCPIP_THREAD_NAME, TCPIP_THREAD_PRIO, and TCPIP_THREAD_STACKSIZE.

{
  lwip_init();//³õʼ»¯ÄÚºË
  tcpip_init_done = initfunc;//×¢²áÓû§×Ô¶¨Ò庯Êý
  tcpip_init_done_arg = arg;//º¯Êý²ÎÊý
  if(sys_mbox_new(&mbox, TCPIP_MBOX_SIZE) != ERR_OK) {//´´½¨ÄÚºËÓÊÏä
    LWIP_ASSERT("failed to create tcpip_thread mbox", 0);
  }
#if LWIP_TCPIP_CORE_LOCKING
  if(sys_mutex_new(&lock_tcpip_core) != ERR_OK) {
    LWIP_ASSERT("failed to create lock_tcpip_core", 0);
  }
#endif /* LWIP_TCPIP_CORE_LOCKING */

  sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);//´´½¨Äں˽ø³Ì
}


  tcpip_init_done = initfunc;//×¢²áÓû§×Ô¶¨Ò庯Êý
  tcpip_init_done_arg = arg;//º¯Êý²ÎÊý  if(sys_mbox_new(&mbox, TCPIP_MBOX_SIZE) != ERR_OK) {//´´½¨ÄÚºËÓÊÏä
    LWIP_ASSERT("failed to create tcpip_thread mbox", 0);
  }
#if LWIP_TCPIP_CORE_LOCKING
  if(sys_mutex_new(&lock_tcpip_core) != ERR_OK) {
    LWIP_ASSERT("failed to create lock_tcpip_core", 0);
  }
#endif /* LWIP_TCPIP_CORE_LOCKING */

  sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);//´´½¨Äں˽ø³Ì
}

  if(sys_mbox_new(&mbox, TCPIP_MBOX_SIZE) != ERR_OK) {//´´½¨ÄÚºËÓÊÏä    LWIP_ASSERT("failed to create tcpip_thread mbox", 0);
  }
#if LWIP_TCPIP_CORE_LOCKING
  if(sys_mutex_new(&lock_tcpip_core) != ERR_OK) {
    LWIP_ASSERT("failed to create lock_tcpip_core", 0);
  }
#endif /* LWIP_TCPIP_CORE_LOCKING */

  sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);//´´½¨Äں˽ø³Ì
}

    LWIP_ASSERT("failed to create tcpip_thread mbox", 0);
  }
#if LWIP_TCPIP_CORE_LOCKING
  if(sys_mutex_new(&lock_tcpip_core) != ERR_OK) {
    LWIP_ASSERT("failed to create lock_tcpip_core", 0);
  }
#endif /* LWIP_TCPIP_CORE_LOCKING */

  sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);//´´½¨Äں˽ø³Ì}

}

Here is the call graph for this function:

tcpip_input()

err_t tcpip_input	(	struct pbuf *	p,
		struct netif *	inp
	)

Pass a received packet to tcpip_thread for input processing

Parameters

p	the received packet, p->payload pointing to the Ethernet header or to an IP header (if inp doesn't have NETIF_FLAG_ETHARP or NETIF_FLAG_ETHERNET flags)
inp	the network interface on which the packet was received

Definition at line 156 of file tcpip.c.

References ERR_MEM, ERR_OK, ERR_VAL, tcpip_msg::inp, ip_input(), LOCK_TCPIP_CORE, LWIP_DEBUGF, mbox, memp_free(), memp_malloc(), tcpip_msg::msg, NETIF_FLAG_ETHARP, NETIF_FLAG_ETHERNET, NULL, tcpip_msg::p, sys_mbox_trypost(), sys_mbox_valid(), TCPIP_DEBUG, TCPIP_MSG_INPKT, tcpip_msg::type, and UNLOCK_TCPIP_CORE.

Referenced by netif_init().

{
#if LWIP_TCPIP_CORE_LOCKING_INPUT
  err_t ret;
  LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_input: PACKET %p/%p\n", (void *)p, (void *)inp));
  LOCK_TCPIP_CORE();
#if LWIP_ETHERNET
  if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {
    ret = ethernet_input(p, inp);
  } else
#endif /* LWIP_ETHERNET */
  {
    ret = ip_input(p, inp);
  }
  UNLOCK_TCPIP_CORE();
  return ret;
#else /* LWIP_TCPIP_CORE_LOCKING_INPUT */
  struct tcpip_msg *msg;

  if (sys_mbox_valid(&mbox)) {
    msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_INPKT);
    if (msg == NULL) {
      return ERR_MEM;
    }

    msg->type = TCPIP_MSG_INPKT;
    msg->msg.inp.p = p;
    msg->msg.inp.netif = inp;
    if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {
      memp_free(MEMP_TCPIP_MSG_INPKT, msg);
      return ERR_MEM;
    }
    return ERR_OK;
  }
  return ERR_VAL;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
}

Here is the call graph for this function:

Here is the caller graph for this function:

tcpip_thread()

static void tcpip_thread ( void *  arg )

static

The main lwIP thread. This thread has exclusive access to lwIP core functions (unless access to them is not locked). Other threads communicate with this thread using message boxes.

It also starts all the timers to make sure they are running in the right thread context.

Parameters

arg	unused argument

Definition at line 74 of file tcpip.c.

References ip_input(), LOCK_TCPIP_CORE, LWIP_ASSERT, LWIP_DEBUGF, LWIP_TCPIP_THREAD_ALIVE, LWIP_UNUSED_ARG, mbox, memp_free(), tcpip_msg::msg, NETIF_FLAG_ETHARP, NETIF_FLAG_ETHERNET, NULL, sys_timeout(), sys_timeouts_mbox_fetch(), sys_untimeout(), TCPIP_DEBUG, tcpip_init_done, tcpip_init_done_arg, TCPIP_MSG_CALLBACK, TCPIP_MSG_INPKT, and UNLOCK_TCPIP_CORE.

Referenced by tcpip_init().

{
  struct tcpip_msg *msg;
  LWIP_UNUSED_ARG(arg);

  if (tcpip_init_done != NULL) {//Óû§×¢²áÁË×Ô¶¨Òå³õʼ»¯º¯Êý
    tcpip_init_done(tcpip_init_done_arg);
  }

  LOCK_TCPIP_CORE();
  while (1) {                          /* MAIN Loop */
    UNLOCK_TCPIP_CORE();
    LWIP_TCPIP_THREAD_ALIVE();
    /* wait for a message, timeouts are processed while waiting */
    sys_timeouts_mbox_fetch(&mbox, (void **)&msg);
    LOCK_TCPIP_CORE();
    switch (msg->type) {
#if LWIP_NETCONN
    case TCPIP_MSG_API://APIµ÷ÓÃ      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));
      msg->msg.apimsg->function(&(msg->msg.apimsg->msg));
      break;
#endif /* LWIP_NETCONN */

#if !LWIP_TCPIP_CORE_LOCKING_INPUT
    case TCPIP_MSG_INPKT://µ×²ãÊý¾Ý°üÊäÈë
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
#if LWIP_ETHERNET
      if (msg->msg.inp.netif->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {//Ö§³ÖARP
        ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);//½»¸øARP´¦Àí
      } else
#endif /* LWIP_ETHERNET */
      {
        ip_input(msg->msg.inp.p, msg->msg.inp.netif);//½»¸øIP´¦Àí
      }
      memp_free(MEMP_TCPIP_MSG_INPKT, msg);
      break;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */

#if LWIP_NETIF_API
    case TCPIP_MSG_NETIFAPI:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: Netif API message %p\n", (void *)msg));
      msg->msg.netifapimsg->function(&(msg->msg.netifapimsg->msg));
      break;
#endif /* LWIP_NETIF_API */

    case TCPIP_MSG_CALLBACK://Éϲã»Øµ÷·½Ê½Ö´ÐÐÒ»¸öº¯Êý
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));
      msg->msg.cb.function(msg->msg.cb.ctx);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;

#if LWIP_TCPIP_TIMEOUT
    case TCPIP_MSG_TIMEOUT://Éϲã×¢²áÒ»¸ö¶¨Ê±Ê¼þ
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
      sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;
    case TCPIP_MSG_UNTIMEOUT://Éϲãɾ³ýÒ»¸ö¶¨Ê±Ê¼þ
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg));
      sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;
#endif /* LWIP_TCPIP_TIMEOUT */

    default:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: %d\n", msg->type));
      LWIP_ASSERT("tcpip_thread: invalid message", 0);
      break;
    }
  }
}

      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));
      msg->msg.apimsg->function(&(msg->msg.apimsg->msg));
      break;
#endif /* LWIP_NETCONN */

#if !LWIP_TCPIP_CORE_LOCKING_INPUT
    case TCPIP_MSG_INPKT://µ×²ãÊý¾Ý°üÊäÈë      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
#if LWIP_ETHERNET
      if (msg->msg.inp.netif->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {//Ö§³ÖARP
        ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);//½»¸øARP´¦Àí
      } else
#endif /* LWIP_ETHERNET */
      {
        ip_input(msg->msg.inp.p, msg->msg.inp.netif);//½»¸øIP´¦Àí
      }
      memp_free(MEMP_TCPIP_MSG_INPKT, msg);
      break;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */

#if LWIP_NETIF_API
    case TCPIP_MSG_NETIFAPI:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: Netif API message %p\n", (void *)msg));
      msg->msg.netifapimsg->function(&(msg->msg.netifapimsg->msg));
      break;
#endif /* LWIP_NETIF_API */

    case TCPIP_MSG_CALLBACK://Éϲã»Øµ÷·½Ê½Ö´ÐÐÒ»¸öº¯Êý
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));
      msg->msg.cb.function(msg->msg.cb.ctx);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;

#if LWIP_TCPIP_TIMEOUT
    case TCPIP_MSG_TIMEOUT://Éϲã×¢²áÒ»¸ö¶¨Ê±Ê¼þ
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
      sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;
    case TCPIP_MSG_UNTIMEOUT://Éϲãɾ³ýÒ»¸ö¶¨Ê±Ê¼þ
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg));
      sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;
#endif /* LWIP_TCPIP_TIMEOUT */

    default:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: %d\n", msg->type));
      LWIP_ASSERT("tcpip_thread: invalid message", 0);
      break;
    }
  }
}

      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
#if LWIP_ETHERNET
      if (msg->msg.inp.netif->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {//Ö§³ÖARP
        ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);//½»¸øARP´¦Àí
      } else
#endif /* LWIP_ETHERNET */
      {
        ip_input(msg->msg.inp.p, msg->msg.inp.netif);//½»¸øIP´¦Àí
      }
      memp_free(MEMP_TCPIP_MSG_INPKT, msg);
      break;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */

#if LWIP_NETIF_API
    case TCPIP_MSG_NETIFAPI:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: Netif API message %p\n", (void *)msg));
      msg->msg.netifapimsg->function(&(msg->msg.netifapimsg->msg));
      break;
#endif /* LWIP_NETIF_API */

    case TCPIP_MSG_CALLBACK://Éϲã»Øµ÷·½Ê½Ö´ÐÐÒ»¸öº¯Êý
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));
      msg->msg.cb.function(msg->msg.cb.ctx);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;

#if LWIP_TCPIP_TIMEOUT
    case TCPIP_MSG_TIMEOUT://Éϲã×¢²áÒ»¸ö¶¨Ê±Ê¼þ
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
      sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;
    case TCPIP_MSG_UNTIMEOUT://Éϲãɾ³ýÒ»¸ö¶¨Ê±Ê¼þ
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg));
      sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg);
      memp_free(MEMP_TCPIP_MSG_API, msg);
      break;
#endif /* LWIP_TCPIP_TIMEOUT */

    default:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: %d\n", msg->type));
      LWIP_ASSERT("tcpip_thread: invalid message", 0);
      break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

mbox

sys_mbox_t mbox

static

Definition at line 55 of file tcpip.c.

Referenced by tcpip_callback_with_block(), tcpip_init(), tcpip_input(), and tcpip_thread().

tcpip_init_done

tcpip_init_done_fn tcpip_init_done

static

Definition at line 53 of file tcpip.c.

Referenced by tcpip_init(), and tcpip_thread().

tcpip_init_done_arg

void* tcpip_init_done_arg

static

Definition at line 54 of file tcpip.c.

Referenced by tcpip_init(), and tcpip_thread().