#include "lwip/opt.h"
#include "lwip/tcpip.h"
#include "lwip/sys.h"
#include "lwip/timeouts.h"

Classes
struct	tcpip_api_call_data

struct	tcpip_msg

Macros
#define	API_VAR_REF(name) name

#define	API_VAR_DECLARE(type, name) type name

#define	API_VAR_ALLOC(type, pool, name, errorval)

#define	API_VAR_ALLOC_POOL(type, pool, name, errorval)

#define	API_VAR_FREE(pool, name)

#define	API_VAR_FREE_POOL(pool, name)

#define	API_EXPR_REF(expr) expr

#define	API_EXPR_REF_SEM(expr) API_EXPR_REF(expr)

#define	API_EXPR_DEREF(expr) (*(expr))

#define	API_MSG_M_DEF(m) *m

#define	API_MSG_M_DEF_C(t, m) const t * m

Typedefs
typedef err_t(*	tcpip_api_call_fn) (struct tcpip_api_call_data *call)

Enumerations
enum	tcpip_msg_type { TCPIP_MSG_API, TCPIP_MSG_API_CALL, TCPIP_MSG_INPKT, TCPIP_MSG_CALLBACK, TCPIP_MSG_CALLBACK_STATIC }

Functions
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)

Detailed Description

TCPIP API internal implementations (do not use in application code)

Macro Definition Documentation

◆ API_VAR_REF

#define API_VAR_REF ( name ) name

◆ API_VAR_DECLARE

#define API_VAR_DECLARE	(	type,
		name
	)	type name

◆ API_VAR_ALLOC

#define API_VAR_ALLOC	(	type,
		pool,
		name,
		errorval
	)

◆ API_VAR_ALLOC_POOL

#define API_VAR_ALLOC_POOL	(	type,
		pool,
		name,
		errorval
	)

◆ API_VAR_FREE

#define API_VAR_FREE	(	pool,
		name
	)

◆ API_VAR_FREE_POOL

#define API_VAR_FREE_POOL	(	pool,
		name
	)

◆ API_EXPR_REF

#define API_EXPR_REF ( expr ) expr

◆ API_EXPR_REF_SEM

#define API_EXPR_REF_SEM ( expr ) API_EXPR_REF(expr)

◆ API_EXPR_DEREF

#define API_EXPR_DEREF ( expr ) (*(expr))

◆ API_MSG_M_DEF

#define API_MSG_M_DEF ( m ) *m

◆ API_MSG_M_DEF_C

#define API_MSG_M_DEF_C	(	t,
		m
	)	const t * m

Typedef Documentation

◆ tcpip_api_call_fn

typedef err_t(* tcpip_api_call_fn) (struct tcpip_api_call_data *call)

Enumeration Type Documentation

◆ tcpip_msg_type

enum tcpip_msg_type

Enumerator
TCPIP_MSG_API
TCPIP_MSG_API_CALL
TCPIP_MSG_INPKT
TCPIP_MSG_CALLBACK
TCPIP_MSG_CALLBACK_STATIC

                     {
   TCPIP_MSG_API,
   TCPIP_MSG_API_CALL,
   TCPIP_MSG_INPKT,
 #if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS
   TCPIP_MSG_TIMEOUT,
   TCPIP_MSG_UNTIMEOUT,
 #endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */
   TCPIP_MSG_CALLBACK,
   TCPIP_MSG_CALLBACK_STATIC
 };

Function Documentation

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