lwIP
2.0.2
Lightweight IP stack
|
#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_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) |
err_t | pbuf_free_callback (struct pbuf *p) |
err_t | mem_free_callback (void *m) |
Variables | |
sys_mutex_t | lock_tcpip_core |
Sequential API Main thread module
err_t mem_free_callback | ( | void * | m | ) |
A simple wrapper function that allows you to free heap memory from interrupt context.
m | the heap memory to free |
A simple wrapper function that allows you to free a pbuf from interrupt context.
p | The pbuf (chain) to be dereferenced. |
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.
fn | Function to call |
call | Call parameters |
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.
function | the function to call |
ctx | parameter passed to f |
block | 1 to block until the request is posted, 0 to non-blocking mode |
void tcpip_callbackmsg_delete | ( | struct tcpip_callback_msg * | msg | ) |
Free a callback message allocated by tcpip_callbackmsg_new().
msg | the message to free |
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.
function | the function to call |
ctx | parameter passed to function |
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
p | the received packet |
inp | the network interface on which the packet was received |
input_fn | input function to call |
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.
fn | function to be called from TCPIP thread |
apimsg | argument to API function |
sem | semaphore to wait on |
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.
msg | pointer to the message to post |
sys_mutex_t lock_tcpip_core |
The global semaphore to lock the stack.