lwIP 2.1.0 Lightweight IP stack

Functions | Variables
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"`

## Functions
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)
void | tcpip_init (tcpip_init_done_fn initfunc, void *arg)
err_t | pbuf_free_callback (struct pbuf *p)
err_t | mem_free_callback (void *m)

## Variables
sys_mutex_t | lock_tcpip_core

## Detailed Description

Sequential API Main thread module

## 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

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

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

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

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

## Variable Documentation

## ◆ lock_tcpip_core

sys_mutex_t lock_tcpip_core

The global semaphore to lock the stack.