tcpip.h File Reference

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

Data Structures
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 }

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

Referenced by tcpip_callback_with_block(), tcpip_input(), and tcpip_thread().

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.

Referenced by tcpip_thread().

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 99 of file tcpip.h.

Referenced by netif_set_link_down().

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.

Referenced by tcpip_callback_with_block(), tcpip_input(), and tcpip_thread().

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

Definition at line 110 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
};

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

References mem_free(), and tcpip_callback_with_block().

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

Here is the call graph for this function:

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

References pbuf_free_int(), and tcpip_callback_with_block().

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

Here is the call graph for this function:

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

References tcpip_msg::cb, tcpip_msg::ctx, ERR_MEM, ERR_OK, ERR_VAL, LOCK_TCPIP_CORE, mbox, memp_free(), memp_malloc(), tcpip_msg::msg, NULL, sys_arch_sem_wait(), sys_mbox_post(), sys_mbox_trypost(), sys_mbox_valid(), sys_sem_free(), sys_sem_new(), sys_sem_wait, TCPIP_MSG_CALLBACK, tcpip_msg::type, and UNLOCK_TCPIP_CORE.

Referenced by mem_free_callback(), and pbuf_free_callback().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

References ERR_OK, LWIP_ASSERT, lwip_init(), mbox, NULL, sys_mbox_new(), sys_mutex_new(), sys_thread_new(), tcpip_init_done, tcpip_init_done_arg, TCPIP_MBOX_SIZE, tcpip_thread(), TCPIP_THREAD_NAME, TCPIP_THREAD_PRIO, and TCPIP_THREAD_STACKSIZE.

{
  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);//´´½¨Äں˽ø³Ì
}


  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);//´´½¨Äں˽ø³Ì
}

  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);//´´½¨Äں˽ø³Ì
}

    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);//´´½¨Äں˽ø³Ì}

}

Here is the call graph for this function:

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

References ERR_MEM, ERR_OK, ERR_VAL, tcpip_msg::inp, ip_input(), LOCK_TCPIP_CORE, LWIP_DEBUGF, mbox, memp_free(), memp_malloc(), tcpip_msg::msg, NETIF_FLAG_ETHARP, NETIF_FLAG_ETHERNET, NULL, tcpip_msg::p, sys_mbox_trypost(), sys_mbox_valid(), TCPIP_DEBUG, TCPIP_MSG_INPKT, tcpip_msg::type, and UNLOCK_TCPIP_CORE.

Referenced by netif_init().

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

Here is the call graph for this function:

Here is the caller graph for this function: