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"

Include dependency graph for tcpip.c:

Go to the source code of this file.

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_handle_msg (struct tcpip_msg *msg)
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 (tcpip_callback_fn function, void *ctx)
err_t	tcpip_try_callback (tcpip_callback_fn function, void *ctx)
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_callbackmsg_trycallback (struct tcpip_callback_msg *msg)
err_t	tcpip_callbackmsg_trycallback_fromisr (struct tcpip_callback_msg *msg)
err_t	tcpip_callback_wait (tcpip_callback_fn function, void *ctx)
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	tcpip_mbox

Detailed Description

Sequential API Main thread module

Definition in file tcpip.c.

Macro Definition Documentation

TCPIP_MBOX_FETCH

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

Definition at line 72 of file tcpip.c.

TCPIP_MSG_VAR_ALLOC

#define TCPIP_MSG_VAR_ALLOC

(

name

)

API_VAR_ALLOC(struct tcpip_msg, MEMP_TCPIP_MSG_API, name, ERR_MEM)

Definition at line 55 of file tcpip.c.

TCPIP_MSG_VAR_DECLARE

#define TCPIP_MSG_VAR_DECLARE

(

name

)

API_VAR_DECLARE(struct tcpip_msg, name)

Definition at line 54 of file tcpip.c.

TCPIP_MSG_VAR_FREE

#define TCPIP_MSG_VAR_FREE

(

name

)

API_VAR_FREE(MEMP_TCPIP_MSG_API, name)

Definition at line 56 of file tcpip.c.

TCPIP_MSG_VAR_REF

#define TCPIP_MSG_VAR_REF

(

name

)

API_VAR_REF(name)

Definition at line 53 of 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 701 of file tcpip.c.

{
  return tcpip_try_callback(mem_free, m);
}

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 688 of file tcpip.c.

{
  return tcpip_try_callback(pbuf_free_int, p);
}

Referenced by LibTCPGetDataFromConnectionQueue().

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 675 of file tcpip.c.

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

Referenced by pbuf_free_callback().

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

Definition at line 478 of file tcpip.c.

{
#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(tcpip_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(&tcpip_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 */
}

tcpip_callback_wait()

err_t tcpip_callback_wait	(	tcpip_callback_fn	function,
		void *	ctx
	)

Sends a message to TCPIP thread to call a function. Caller thread blocks until the function returns. 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

function	the function to call
ctx	parameter passed to f

Returns

ERR_OK if the function was called, another err_t if not

Definition at line 610 of file tcpip.c.

{
#if LWIP_TCPIP_CORE_LOCKING
  LOCK_TCPIP_CORE();
  function(ctx);
  UNLOCK_TCPIP_CORE();
  return ERR_OK;
#else /* LWIP_TCPIP_CORE_LOCKING */
  err_t err;
  sys_sem_t sem;
  struct tcpip_msg msg;
 
  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox));
 
  err = sys_sem_new(&sem, 0);
  if (err != ERR_OK) {
    return err;
  }
 
  msg.type = TCPIP_MSG_CALLBACK_STATIC_WAIT;
  msg.msg.cb_wait.function = function;
  msg.msg.cb_wait.ctx = ctx;
  msg.msg.cb_wait.sem = &sem;
  sys_mbox_post(&tcpip_mbox, &msg);
  sys_arch_sem_wait(&sem, 0);
  sys_sem_free(&sem);
  return ERR_OK;
#endif /* LWIP_TCPIP_CORE_LOCKING */
}

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

Definition at line 245 of file tcpip.c.

{
#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(tcpip_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(&tcpip_mbox, msg) != ERR_OK) {
    memp_free(MEMP_TCPIP_MSG_INPKT, msg);
    return ERR_MEM;
  }
  return ERR_OK;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
}

Referenced by tcpip_input().

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

Definition at line 442 of file tcpip.c.

{
#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(tcpip_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(&tcpip_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 */
}

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 127 of file tcpip.c.

{
  struct tcpip_msg *msg;
  LWIP_UNUSED_ARG(arg);
 
  LWIP_MARK_TCPIP_THREAD();
 
  LOCK_TCPIP_CORE();
  if (tcpip_init_done != NULL) {
    tcpip_init_done(tcpip_init_done_arg);
  }
 
  while (1) {                          /* MAIN Loop */
    LWIP_TCPIP_THREAD_ALIVE();
    /* wait for a message, timeouts are processed while waiting */
    TCPIP_MBOX_FETCH(&tcpip_mbox, (void **)&msg);
    if (msg == NULL) {
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: NULL\n"));
      LWIP_ASSERT("tcpip_thread: invalid message", 0);
      continue;
    }
    tcpip_thread_handle_msg(msg);
  }
}

Referenced by tcpip_init().

tcpip_thread_handle_msg()

static void tcpip_thread_handle_msg ( struct tcpip_msg *  msg )

static

Definition at line 156 of file tcpip.c.

{
  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;
    case TCPIP_MSG_CALLBACK_STATIC_WAIT:
      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK WAIT message %p\n", (void *)msg));
      msg->msg.cb_wait.function(msg->msg.cb_wait.ctx);
      sys_sem_signal(msg->msg.cb_wait.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));
      if (msg->msg.inp.input_fn(msg->msg.inp.p, msg->msg.inp.netif) != ERR_OK) {
        pbuf_free(msg->msg.inp.p);
      }
      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;
  }
}

Referenced by tcpip_thread().

Variable Documentation

tcpip_init_done

tcpip_init_done_fn tcpip_init_done

static

Definition at line 59 of file tcpip.c.

Referenced by tcpip_init(), and tcpip_thread().

tcpip_init_done_arg

void* tcpip_init_done_arg

static

Definition at line 60 of file tcpip.c.

Referenced by tcpip_init(), and tcpip_thread().

tcpip_mbox

sys_mbox_t tcpip_mbox

static

Definition at line 61 of file tcpip.c.

Referenced by tcpip_api_call(), tcpip_callback(), tcpip_callback_wait(), tcpip_callbackmsg_trycallback(), tcpip_callbackmsg_trycallback_fromisr(), tcpip_init(), tcpip_inpkt(), tcpip_send_msg_wait_sem(), tcpip_thread(), and tcpip_try_callback().