tcpip.c File Reference

#include "lwip/opt.h"
#include "lwip/priv/tcpip_priv.h"
#include "lwip/sys.h"
#include "lwip/memp.h"
#include "lwip/mem.h"
#include "lwip/init.h"
#include "lwip/ip.h"
#include "lwip/pbuf.h"
#include "lwip/etharp.h"
#include "netif/ethernet.h"

Macros
#define	TCPIP_MSG_VAR_REF(name)   API_VAR_REF(name)
#define	TCPIP_MSG_VAR_DECLARE(name)   API_VAR_DECLARE(struct tcpip_msg, name)
#define	TCPIP_MSG_VAR_ALLOC(name)   API_VAR_ALLOC(struct tcpip_msg, MEMP_TCPIP_MSG_API, name, ERR_MEM)
#define	TCPIP_MSG_VAR_FREE(name)   API_VAR_FREE(MEMP_TCPIP_MSG_API, name)
#define	TCPIP_MBOX_FETCH(mbox, msg)   sys_mbox_fetch(mbox, msg)

Functions
static void	tcpip_thread (void *arg)
err_t	tcpip_inpkt (struct pbuf *p, struct netif *inp, netif_input_fn input_fn)
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)
err_t	tcpip_send_msg_wait_sem (tcpip_callback_fn fn, void *apimsg, sys_sem_t *sem)
err_t	tcpip_api_call (tcpip_api_call_fn fn, struct tcpip_api_call_data *call)
struct tcpip_callback_msg *	tcpip_callbackmsg_new (tcpip_callback_fn function, void *ctx)
void	tcpip_callbackmsg_delete (struct tcpip_callback_msg *msg)
err_t	tcpip_trycallback (struct tcpip_callback_msg *msg)
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

Macro Definition Documentation

TCPIP_MSG_VAR_REF

#define TCPIP_MSG_VAR_REF

(

name

)

API_VAR_REF(name)

TCPIP_MSG_VAR_DECLARE

#define TCPIP_MSG_VAR_DECLARE

(

name

)

API_VAR_DECLARE(struct tcpip_msg, name)

TCPIP_MSG_VAR_ALLOC

#define TCPIP_MSG_VAR_ALLOC

(

name

)

API_VAR_ALLOC(struct tcpip_msg, MEMP_TCPIP_MSG_API, name, ERR_MEM)

TCPIP_MSG_VAR_FREE

#define TCPIP_MSG_VAR_FREE

(

name

)

API_VAR_FREE(MEMP_TCPIP_MSG_API, name)

TCPIP_MBOX_FETCH

#define TCPIP_MBOX_FETCH	(		mbox,
			msg
	)		sys_mbox_fetch(mbox, msg)

Function Documentation

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

{
  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 */
    TCPIP_MBOX_FETCH(&mbox, (void **)&msg);
    LOCK_TCPIP_CORE();
    if (msg == NULL) {
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: NULL\n"));
      LWIP_ASSERT("tcpip_thread: invalid message", 0);
      continue;
    }
    switch (msg->type) {
#if !LWIP_TCPIP_CORE_LOCKING
    case TCPIP_MSG_API:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));
      msg->msg.api_msg.function(msg->msg.api_msg.msg);
      break;
    case TCPIP_MSG_API_CALL:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API CALL message %p\n", (void *)msg));
      msg->msg.api_call.arg->err = msg->msg.api_call.function(msg->msg.api_call.arg);
      sys_sem_signal(msg->msg.api_call.sem);
      break;
#endif /* !LWIP_TCPIP_CORE_LOCKING */
 
#if !LWIP_TCPIP_CORE_LOCKING_INPUT
    case TCPIP_MSG_INPKT:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
      msg->msg.inp.input_fn(msg->msg.inp.p, msg->msg.inp.netif);
      memp_free(MEMP_TCPIP_MSG_INPKT, msg);
      break;
#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */
 
#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS
    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 && LWIP_TIMERS */
 
    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;
 
    case TCPIP_MSG_CALLBACK_STATIC:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK_STATIC %p\n", (void *)msg));
      msg->msg.cb.function(msg->msg.cb.ctx);
      break;
 
    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:

tcpip_inpkt()

err_t tcpip_inpkt	(	struct pbuf *	p,
		struct netif *	inp,
		netif_input_fn	input_fn
	)

Pass a received packet to tcpip_thread for input processing

Parameters

p	the received packet
inp	the network interface on which the packet was received
input_fn	input function to call

{
#if LWIP_TCPIP_CORE_LOCKING_INPUT
  err_t ret;
  LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_inpkt: PACKET %p/%p\n", (void *)p, (void *)inp));
  LOCK_TCPIP_CORE();
  ret = input_fn(p, inp);
  UNLOCK_TCPIP_CORE();
  return ret;
#else /* LWIP_TCPIP_CORE_LOCKING_INPUT */
  struct tcpip_msg *msg;
 
  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(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;
  msg->msg.inp.input_fn = input_fn;
  if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {
    memp_free(MEMP_TCPIP_MSG_INPKT, msg);
    return ERR_MEM;
  }
  return ERR_OK;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
}

Here is the call graph for this function:

Here is the caller 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 with ethernet_input or ip_input. Don't call directly, pass to netif_add() and call netif->input().

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

{
#if LWIP_ETHERNET
  if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {
    return tcpip_inpkt(p, inp, ethernet_input);
  } else
#endif /* LWIP_ETHERNET */
  return tcpip_inpkt(p, inp, ip_input);
}

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

function	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

{
  struct tcpip_msg *msg;
 
  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tcpip_send_msg_wait_sem()

err_t tcpip_send_msg_wait_sem	(	tcpip_callback_fn	fn,
		void *	apimsg,
		sys_sem_t *	sem
	)

Sends a message to TCPIP thread to call a function. Caller thread blocks on on a provided semaphore, which ist NOT automatically signalled by TCPIP thread, this has to be done by the user. It is recommended to use LWIP_TCPIP_CORE_LOCKING since this is the way with least runtime overhead.

Parameters

fn	function to be called from TCPIP thread
apimsg	argument to API function
sem	semaphore to wait on

Returns

ERR_OK if the function was called, another err_t if not

{
#if LWIP_TCPIP_CORE_LOCKING
  LWIP_UNUSED_ARG(sem);
  LOCK_TCPIP_CORE();
  fn(apimsg);
  UNLOCK_TCPIP_CORE();
  return ERR_OK;
#else /* LWIP_TCPIP_CORE_LOCKING */
  TCPIP_MSG_VAR_DECLARE(msg);
 
  LWIP_ASSERT("semaphore not initialized", sys_sem_valid(sem));
  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(mbox));
 
  TCPIP_MSG_VAR_ALLOC(msg);
  TCPIP_MSG_VAR_REF(msg).type = TCPIP_MSG_API;
  TCPIP_MSG_VAR_REF(msg).msg.api_msg.function = fn;
  TCPIP_MSG_VAR_REF(msg).msg.api_msg.msg = apimsg;
  sys_mbox_post(&mbox, &TCPIP_MSG_VAR_REF(msg));
  sys_arch_sem_wait(sem, 0);
  TCPIP_MSG_VAR_FREE(msg);
  return ERR_OK;
#endif /* LWIP_TCPIP_CORE_LOCKING */
}

Here is the call graph for this function:

tcpip_api_call()

err_t tcpip_api_call	(	tcpip_api_call_fn	fn,
		struct tcpip_api_call_data *	call
	)

Synchronously calls function in TCPIP thread and waits for its completion. It is recommended to use LWIP_TCPIP_CORE_LOCKING (preferred) or LWIP_NETCONN_SEM_PER_THREAD. If not, a semaphore is created and destroyed on every call which is usually an expensive/slow operation.

Parameters

fn	Function to call
call	Call parameters

Returns

Return value from tcpip_api_call_fn

{
#if LWIP_TCPIP_CORE_LOCKING
  err_t err;
  LOCK_TCPIP_CORE();
  err = fn(call);
  UNLOCK_TCPIP_CORE();
  return err;
#else /* LWIP_TCPIP_CORE_LOCKING */
  TCPIP_MSG_VAR_DECLARE(msg);
 
#if !LWIP_NETCONN_SEM_PER_THREAD
  err_t err = sys_sem_new(&call->sem, 0);
  if (err != ERR_OK) {
    return err;
  }
#endif /* LWIP_NETCONN_SEM_PER_THREAD */
 
  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(mbox));
 
  TCPIP_MSG_VAR_ALLOC(msg);
  TCPIP_MSG_VAR_REF(msg).type = TCPIP_MSG_API_CALL;
  TCPIP_MSG_VAR_REF(msg).msg.api_call.arg = call;
  TCPIP_MSG_VAR_REF(msg).msg.api_call.function = fn;
#if LWIP_NETCONN_SEM_PER_THREAD
  TCPIP_MSG_VAR_REF(msg).msg.api_call.sem = LWIP_NETCONN_THREAD_SEM_GET();
#else /* LWIP_NETCONN_SEM_PER_THREAD */
  TCPIP_MSG_VAR_REF(msg).msg.api_call.sem = &call->sem;
#endif /* LWIP_NETCONN_SEM_PER_THREAD */
  sys_mbox_post(&mbox, &TCPIP_MSG_VAR_REF(msg));
  sys_arch_sem_wait(TCPIP_MSG_VAR_REF(msg).msg.api_call.sem, 0);
  TCPIP_MSG_VAR_FREE(msg);
 
#if !LWIP_NETCONN_SEM_PER_THREAD
  sys_sem_free(&call->sem);
#endif /* LWIP_NETCONN_SEM_PER_THREAD */
 
  return call->err;
#endif /* LWIP_TCPIP_CORE_LOCKING */
}

Here is the call graph for this function:

tcpip_callbackmsg_new()

struct tcpip_callback_msg* tcpip_callbackmsg_new	(	tcpip_callback_fn	function,
		void *	ctx
	)

Allocate a structure for a static callback message and initialize it. This is intended to be used to send "static" messages from interrupt context.

Parameters

function	the function to call
ctx	parameter passed to function

Returns

a struct pointer to pass to tcpip_trycallback().

{
  struct tcpip_msg *msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API);
  if (msg == NULL) {
    return NULL;
  }
  msg->type = TCPIP_MSG_CALLBACK_STATIC;
  msg->msg.cb.function = function;
  msg->msg.cb.ctx = ctx;
  return (struct tcpip_callback_msg*)msg;
}

Here is the call graph for this function:

tcpip_callbackmsg_delete()

void tcpip_callbackmsg_delete

(

struct tcpip_callback_msg *

msg

)

Free a callback message allocated by tcpip_callbackmsg_new().

Parameters

msg	the message to free

{
  memp_free(MEMP_TCPIP_MSG_API, msg);
}

Here is the call graph for this function:

tcpip_trycallback()

err_t tcpip_trycallback

(

struct tcpip_callback_msg *

msg

)

Try to post a callback-message to the tcpip_thread mbox This is intended to be used to send "static" messages from interrupt context.

Parameters

msg	pointer to the message to post

Returns

sys_mbox_trypost() return code

{
  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(mbox));
  return sys_mbox_trypost(&mbox, msg);
}

Here is the call 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

{
  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);
}

Here is the call graph for this function:

Here is the caller 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.

{
  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:

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

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

Here is the call graph for this function:

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

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

Here is the call graph for this function:

Variable Documentation

tcpip_init_done

tcpip_init_done_fn tcpip_init_done

static

tcpip_init_done_arg

void* tcpip_init_done_arg

static

mbox

sys_mbox_t mbox

static