LWIP 1.4.1 TCP stresses memory leaks & (tiva-tm4c129.c) configuration - timers, types of PCB.

There are hidden LWIP options (LWIP_RAW==1 and (RAW_PCB == 4) defined defaults in (opt.h). 
 
There are no (raw_pcb) calls made to (raw.c) in the Exosite program and LWIP_RAW optionally need not be enabled. 

Memory pool buffers Overflow and Sanity checks were not being enabled == 1 in (lwipopts.h) or (opt.h).

(memp.c) remove (!) to allow sanity checks and to add PCB overflow constraints. 

#if (!)MEMP_MEM_MALLOC /* don't build if not using pools configured for use in lwipopts.h */

struct memp {
  struct memp *next;
#if MEMP_OVERFLOW_CHECK
  const char *file;
  int line;
#endif /* MEMP_OVERFLOW_CHECK */
};

Reasons why (PBUF_TRANSPORT) && (PBUF_RAM) are better suited for the task lies mainly in the vendor DMA RX-Descriptors struct (tiva-tm4c129.c) uses for allocating ample space that receive packets fit in to each PCB stored in SRAM.   

Seemingly PCB_POOL was intended for LWIP internal use (tcp-out.c / tcp_in.c). Perhaps the vendor layer should refrain from using PCB_POOL for temporary packet storage prior to filtering data into the application layer. Likewise it would seem vendor using PBUF_RAW (layer) class does not allocate enough PBUF space in SRAM to hold the entire RX-Descriptor recovered scatter DMA delivered by (tcp_in.c) at the transport layer?

Seemingly Layer class PBUF_TRANSPORT a better choice to allocate enough SRAM PBUF space for incoming Received packets including {TCP_MSS, IP header, link header}, otherwise Packet drops may occur at the PHY devise layer. 

CSMCSDA collision avoidance in the MLINK adds to the time spent at device layer for receiving incoming packets so packet drops count. 

Hence packet Frame handling and configuration miss-matching at ascending TCP layers can directly impact the device layer. Setting to high of a TCP_MSS (1500) may also add to the number of dropped receive packets from the Host if or when the vendor transport layer is struggling. 

LWIP (tcp_out.c) 3 Phases :

    /*
     * Phase 1: Copy data directly into an oversized pbuf.
     * The number of bytes copied is recorded in the oversize_used
     * variable. The actual copying is done at the bottom of the
     * function.
     */
#if TCP_OVERSIZE
#if TCP_OVERSIZE_DBGCHECK
    /* check that pcb->unsent_oversize matches last_unsent->unsent_oversize */
    LWIP_ASSERT("unsent_oversize mismatch (pcb vs. last_unsent)",
                pcb->unsent_oversize == last_unsent->oversize_left);
#endif /* TCP_OVERSIZE_DBGCHECK */

~~~~~~~~~~~~

/* Phase 2: Create a pbuf with a copy or reference to seglen bytes. We
       * can use PBUF_RAW here since the data appears in the middle of
       * a segment. A header will never be prepended. */
      if (apiflags & TCP_WRITE_FLAG_COPY) {
        /* Data is copied */
        if ((concat_p = tcp_pbuf_prealloc(PBUF_RAW, seglen, space, &oversize, pcb, apiflags, 1)) == NULL) {
          LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2,
                      ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n",
                       seglen));
          goto memerr;
        }

~~~~~~~~~~~

 /*
   * Phase 3: Create new segments.
   * The new segments are chained together in the local 'queue'
   * variable, ready to be appended to pcb->unsent.
   */
  while (pos < len) {
    struct pbuf *p;
    u16_t left = len - pos;
    u16_t max_len = mss_local - optlen;
    u16_t seglen = left > max_len ? max_len : left;
#if TCP_CHECKSUM_ON_COPY
    u16_t chksum = 0;
    u8_t chksum_swapped = 0;
#endif /* TCP_CHECKSUM_ON_COPY */

    if (apiflags & TCP_WRITE_FLAG_COPY) {
      /* If copy is set, memory should be allocated and data copied
       * into pbuf */
      if ((p = tcp_pbuf_prealloc(PBUF_TRANSPORT, seglen + optlen, mss_local, &oversize, pcb, apiflags, queue == NULL)) == NULL) {
        LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n", seglen));
        goto memerr;
      }

The function mem_free() de-allocates chained PBUFs. The application loop should periodically make calls to {sys_check_timeouts()} to harvest OOSEQ PBUF (timers.c) when the PBUF_POOL runs dry given the (lwipopt.h) settings below.

Not exactly sure the default LWIP timeout value when (NO_SYS==0) is harvesting 1 OSSEQ PBUF when the PBUF_POOL runs dry.  Default LWIP settings appear contrary to Adam Dunkles Swedish Institute readme text surrounding the function below.

It would seem believed the LWIP module timeout function triggered from defaults in LWIP configuration.

Defaults for NO_SYS==1 : TCP_QUEUE_OOSEQ == 1,  MEMP_NUM_TCP_TIMEOUTS ==7 {Total of LWIP modules}.

(pbuf.h)

#if LWIP_TCP && TCP_QUEUE_OOSEQ
/** Define this to 0 to prevent freeing ooseq pbufs when the PBUF_POOL is empty */
#ifndef PBUF_POOL_FREE_OOSEQ
#define PBUF_POOL_FREE_OOSEQ 1
#endif /* PBUF_POOL_FREE_OOSEQ */
#if NO_SYS && PBUF_POOL_FREE_OOSEQ
extern volatile u8_t pbuf_free_ooseq_pending;
void pbuf_free_ooseq();
/** When not using sys_check_timeouts(), call PBUF_CHECK_FREE_OOSEQ()
    at regular intervals from main level to check if ooseq pbufs need to be
    freed! */
#define PBUF_CHECK_FREE_OOSEQ() do { if(pbuf_free_ooseq_pending) { \
  /* pbuf_alloc() reported PBUF_POOL to be empty -> try to free some \
     ooseq queued pbufs now */ \
  pbuf_free_ooseq(); }}while(0)
#endif /* NO_SYS && PBUF_POOL_FREE_OOSEQ*/
#endif /* LWIP_TCP && TCP_QUEUE_OOSEQ */

(timers.c)

#if NO_SYS

/** Handle timeouts for NO_SYS==1 (i.e. without using
 * tcpip_thread/sys_timeouts_mbox_fetch(). Uses sys_now() to call timeout
 * handler functions when timeouts expire.
 *
 * Must be called periodically from your main loop.
 */
void
sys_check_timeouts(void)
{
  if (next_timeout) {
    struct sys_timeo *tmptimeout;
    u32_t diff;
    sys_timeout_handler handler;
    void *arg;
    u8_t had_one;
    u32_t now;

    now = sys_now();
    /* this cares for wraparounds */
    diff = now - timeouts_last_time;
    do
    {
#if PBUF_POOL_FREE_OOSEQ
      PBUF_CHECK_FREE_OOSEQ();
#endif /* PBUF_POOL_FREE_OOSEQ */
      had_one = 0;
      tmptimeout = next_timeout;
      if (tmptimeout && (tmptimeout->time <= diff)) {
        /* timeout has expired */
        had_one = 1;
        timeouts_last_time = now;
        diff -= tmptimeout->time;
        next_timeout = tmptimeout->next;
        handler = tmptimeout->h;
        arg = tmptimeout->arg;
#if LWIP_DEBUG_TIMERNAMES
        if (handler != NULL) {
          LWIP_DEBUGF(TIMERS_DEBUG, ("sct calling h=%s arg=%p\n",
            tmptimeout->handler_name, arg));
        }
#endif /* LWIP_DEBUG_TIMERNAMES */
        memp_free(MEMP_SYS_TIMEOUT, tmptimeout);
        if (handler != NULL) {
          handler(arg);
        }
      }
    /* repeat until all expired timers have been called */
    }while(had_one);
  }
}