#include "lwip/opt.h"
#include "lwip/api_msg.h"
#include "lwip/netifapi.h"
#include "lwip/pbuf.h"
#include "lwip/api.h"
#include "lwip/sys.h"
#include "lwip/timers.h"
#include "lwip/netif.h"

Include dependency graph for tcpip.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tcpip_msg

Macros
#define	LWIP_TCPIP_THREAD_ALIVE()

#define	LOCK_TCPIP_CORE()

#define	UNLOCK_TCPIP_CORE()

#define	TCPIP_APIMSG(m) tcpip_apimsg(m)

#define	TCPIP_APIMSG_ACK(m) sys_sem_signal(&m->conn->op_completed)

#define	TCPIP_NETIFAPI(m) tcpip_netifapi(m)

#define	TCPIP_NETIFAPI_ACK(m) sys_sem_signal(&m->sem)

#define	tcpip_callback(f, ctx) tcpip_callback_with_block(f, ctx, 1)

Typedefs
typedef void(*	tcpip_init_done_fn) (void *arg)

typedef void(*	tcpip_callback_fn) (void *ctx)

Enumerations
enum	tcpip_msg_type { TCPIP_MSG_INPKT , TCPIP_MSG_CALLBACK , TCPIP_MSG_CALLBACK_STATIC }

Functions
void	tcpip_init (tcpip_init_done_fn tcpip_init_done, 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)

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)

err_t	pbuf_free_callback (struct pbuf *p)

err_t	mem_free_callback (void *m)

Macro Definition Documentation

◆ LOCK_TCPIP_CORE

#define LOCK_TCPIP_CORE ( )

Definition at line 67 of file tcpip.h.

◆ LWIP_TCPIP_THREAD_ALIVE

#define LWIP_TCPIP_THREAD_ALIVE ( )

Define this to something that triggers a watchdog. This is called from tcpip_thread after processing a message.

Definition at line 54 of file tcpip.h.

◆ TCPIP_APIMSG

#define TCPIP_APIMSG ( m ) tcpip_apimsg(m)

Definition at line 69 of file tcpip.h.

◆ TCPIP_APIMSG_ACK

#define TCPIP_APIMSG_ACK ( m ) sys_sem_signal(&m->conn->op_completed)

Definition at line 70 of file tcpip.h.

◆ tcpip_callback

#define tcpip_callback	(	f,
		ctx
	)	tcpip_callback_with_block(f, ctx, 1)

Definition at line 102 of file tcpip.h.

◆ TCPIP_NETIFAPI

#define TCPIP_NETIFAPI ( m ) tcpip_netifapi(m)

Definition at line 71 of file tcpip.h.

◆ TCPIP_NETIFAPI_ACK

#define TCPIP_NETIFAPI_ACK ( m ) sys_sem_signal(&m->sem)

Definition at line 72 of file tcpip.h.

◆ UNLOCK_TCPIP_CORE

#define UNLOCK_TCPIP_CORE ( )

Definition at line 68 of file tcpip.h.

Typedef Documentation

◆ tcpip_callback_fn

typedef void(* tcpip_callback_fn) (void *ctx)

Function prototype for functions passed to tcpip_callback()

Definition at line 78 of file tcpip.h.

◆ tcpip_init_done_fn

typedef void(* tcpip_init_done_fn) (void *arg)

Function prototype for the init_done function passed to tcpip_init

Definition at line 76 of file tcpip.h.

Enumeration Type Documentation

◆ tcpip_msg_type

enum tcpip_msg_type

Enumerator
TCPIP_MSG_INPKT
TCPIP_MSG_CALLBACK
TCPIP_MSG_CALLBACK_STATIC

Definition at line 117 of file tcpip.h.

                    {
#if LWIP_NETCONN
  TCPIP_MSG_API,
#endif /* LWIP_NETCONN */
  TCPIP_MSG_INPKT,
#if LWIP_NETIF_API
  TCPIP_MSG_NETIFAPI,
#endif /* LWIP_NETIF_API */
#if LWIP_TCPIP_TIMEOUT
  TCPIP_MSG_TIMEOUT,
  TCPIP_MSG_UNTIMEOUT,
#endif /* LWIP_TCPIP_TIMEOUT */
  TCPIP_MSG_CALLBACK,
  TCPIP_MSG_CALLBACK_STATIC
};

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

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

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

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

Referenced by LibTCPGetDataFromConnectionQueue().

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

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

Referenced by LibTCPBind(), LibTCPClose(), LibTCPConnect(), LibTCPFreeSocket(), LibTCPListen(), LibTCPSend(), LibTCPShutdown(), LibTCPSocket(), mem_free_callback(), and pbuf_free_callback().

◆ 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

Definition at line 428 of file tcpip.c.

{
  memp_free(MEMP_TCPIP_MSG_API, msg);
}

◆ 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().

Definition at line 411 of file tcpip.c.

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

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

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

Referenced by LibIPInitialize().

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

{
#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)) {
    return ERR_VAL;
  }
  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;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
}

Referenced by netif_init(), and TCPRegisterInterface().

◆ 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

Definition at line 441 of file tcpip.c.

{
  if (!sys_mbox_valid(&mbox)) {
    return ERR_VAL;
  }
  return sys_mbox_trypost(&mbox, msg);
}

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ LOCK_TCPIP_CORE

◆ LWIP_TCPIP_THREAD_ALIVE

◆ TCPIP_APIMSG

◆ TCPIP_APIMSG_ACK

◆ tcpip_callback

◆ TCPIP_NETIFAPI

◆ TCPIP_NETIFAPI_ACK

◆ UNLOCK_TCPIP_CORE

Typedef Documentation

◆ tcpip_callback_fn

◆ tcpip_init_done_fn

Enumeration Type Documentation

◆ tcpip_msg_type

Function Documentation

◆ mem_free_callback()

◆ pbuf_free_callback()

◆ tcpip_callback_with_block()

◆ tcpip_callbackmsg_delete()

◆ tcpip_callbackmsg_new()

◆ tcpip_init()

◆ tcpip_input()

◆ tcpip_trycallback()