text: #ifndef __LWIPOPTS_LIBRARY_H__
  #define __LWIPOPTS_LIBRARY_H__
  //#include "debug.h"
  
  
  /**
   * LWIP_TIMERS_CUSTOM==1: Provide your own timer implementation.
   * Function prototypes in timeouts.h and the array of lwip-internal cyclic timers
   * are still included, but the implementation is not. The following functions
   * will be required: sys_timeouts_init(), sys_timeout(), sys_untimeout(),
   *                   sys_timeouts_mbox_fetch()
   */
  #define LWIP_TIMERS_CUSTOM              0
  
  /**
   * MEMCPY: override this if you have a faster implementation at hand than the
   * one included in your C library
   */
  //extern void * __memcpy(const void *, const void * , unsigned int len);
  
  //#define MEMCPY(dst,src,len)             memcpy(dst,src,len)//clyu// __memcpy
  
  /**
   * SMEMCPY: override this with care! Some compilers (e.g. gcc) can inline a
   * call to memcpy() if the length is known at compile time and is small.
   */
  //#define SMEMCPY(dst,src,len)            memcpy(dst,src,len)
  
  /**
   * LWIP_TCPIP_CORE_LOCKING
   * Creates a global mutex that is held during TCPIP thread operations.
   * Can be locked by client code to perform lwIP operations without changing
   * into TCPIP thread using callbacks. See LOCK_TCPIP_CORE() and
   * UNLOCK_TCPIP_CORE().
   * Your system should provide mutexes supporting priority inversion to use this.
   */
  #define LWIP_TCPIP_CORE_LOCKING         1
  
  /**
   * LWIP_TCPIP_CORE_LOCKING_INPUT: when LWIP_TCPIP_CORE_LOCKING is enabled,
   * this lets tcpip_input() grab the mutex for input packets as well,
   * instead of allocating a message and passing it to tcpip_thread.
   *
   * ATTENTION: this does not work when tcpip_input() is called from
   * interrupt context!
   */
  //#define LWIP_TCPIP_CORE_LOCKING_INPUT   1//clyu
  
  /**
   * MEM_ALIGNMENT: should be set to the alignment of the CPU
   *    4 byte alignment -> \#define MEM_ALIGNMENT 4
   *    2 byte alignment -> \#define MEM_ALIGNMENT 2
   */
  #define MEM_ALIGNMENT                   4
  
  /**
   * LWIP_ARP==1: Enable ARP functionality.
   */
  #define LWIP_ARP                        1
  
  /**
   * ARP_TABLE_SIZE: Number of active MAC-IP address pairs cached.
   */
  #define ARP_TABLE_SIZE                  4
  
  /** the time an ARP entry stays valid after its last update,
   *  for ARP_TMR_INTERVAL = 1000, this is
   *  (60 * 5) seconds = 5 minutes.
   */
  #define ARP_MAXAGE                      300
  
  /**
   * ARP_QUEUEING==1: Multiple outgoing packets are queued during hardware address
   * resolution. By default, only the most recent packet is queued per IP address.
   * This is sufficient for most protocols and mainly reduces TCP connection
   * startup time. Set this to 1 if you know your application sends more than one
   * packet in a row to an IP address that is not in the ARP cache.
   */
  #define ARP_QUEUEING                    0
  
  /** The maximum number of packets which may be queued for each
   *  unresolved address by other network layers. Defaults to 3, 0 means disabled.
   *  Old packets are dropped, new packets are queued.
   */
  #define ARP_QUEUE_LEN                   3
  
  /** LWIP_ETHERNET==1: enable ethernet support even though ARP might be disabled
   */
  #define LWIP_ETHERNET                   1
  
  /** ETH_PAD_SIZE: number of bytes added before the ethernet header to ensure
   * alignment of payload after that header. Since the header is 14 bytes long,
   * without this padding e.g. addresses in the IP header will not be aligned
   * on a 32-bit boundary, so setting this to 2 can speed up 32-bit-platforms.
   */
  #define ETH_PAD_SIZE                    0
  
  /** ETHARP_SUPPORT_STATIC_ENTRIES==1: enable code to support static ARP table
   * entries (using etharp_add_static_entry/etharp_remove_static_entry).
   */
  #define ETHARP_SUPPORT_STATIC_ENTRIES   0
  
  /** ETHARP_TABLE_MATCH_NETIF==1: Match netif for ARP table entries.
   * If disabled, duplicate IP address on multiple netifs are not supported
   * (but this should only occur for AutoIP).
   */
  #define ETHARP_TABLE_MATCH_NETIF        0
  
  /**
   * LWIP_ICMP==1: Enable ICMP module inside the IP stack.
   * Be careful, disable that make your product non-compliant to RFC1122
   */
  #define LWIP_ICMP                       1
  
  #define LWIP_PING                       0
  
  /**
   * LWIP_DHCP==1: Enable DHCP module.
   */
  #define LWIP_DHCP                       0 //clyu
  
  /**
   * LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS
   * transport.
   */
  //#define LWIP_DNS                        1
  
  /** DNS maximum host name length supported in the name table. */
  #define DNS_MAX_NAME_LENGTH             256
  
  /** The maximum of DNS servers
   * The first server can be initialized automatically by defining
   * DNS_SERVER_ADDRESS(ipaddr), where 'ipaddr' is an 'ip_addr_t*'
   */
  #define DNS_MAX_SERVERS                 2
  
  /*
      static const struct ip4_addr dnsg = {PP_HTONL(LWIP_MAKEU32(208, 67, 222, 222))};
  
      if 3 servers are defined, the 3rd is fixed to 8.8.8.8. This might be a good idea incase if the configured dns servers do not work.
      But for this the max servers defined above need to be atleast 3 and the application layer should not override it.
  */
  #define DNS_SERVER_ADDRESS(x)                       IP_ADDR4(x, 192, 168, 1, 1)//clyu
  
  /**
   * LWIP_TCP==1: Turn on TCP.
   */
  #define LWIP_TCP                        1
  
  /**
   * TCP_WND: The size of a TCP window.  This must be at least
   * (2 * TCP_MSS) for things to work well.
   * ATTENTION: when using TCP_RCV_SCALE, TCP_WND is the total size
   * with scaling applied. Maximum window value in the TCP header
   * will be TCP_WND >> TCP_RCV_SCALE
   */
  #define TCP_WND                         (3 * TCP_MSS)
  
  /**
   * TCP_CALCULATE_EFF_SEND_MSS: "The maximum size of a segment that TCP really
   * sends, the 'effective send MSS,' MUST be the smaller of the send MSS (which
   * reflects the available reassembly buffer size at the remote host) and the
   * largest size permitted by the IP layer" (RFC 1122)
   * Setting this to 1 enables code that checks TCP_MSS against the MTU of the
   * netif used for a connection and limits the MSS if it would be too big otherwise.
   */
  #define TCP_CALCULATE_EFF_SEND_MSS      1
  
  /**
   * TCP_SND_BUF: TCP sender buffer space (bytes).
   * To achieve good performance, this should be at least 2 * TCP_MSS.
   */
  #define TCP_SND_BUF                     (3 * TCP_MSS)
  
  /**
   * TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least
   * as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work.
   */
  #define TCP_SND_QUEUELEN                (2 * TCP_SND_BUF/TCP_MSS)
  
  /**
   * TCP_LISTEN_BACKLOG: Enable the backlog option for tcp listen pcb.
   */
  #define TCP_LISTEN_BACKLOG              0
  
  /**
   * TCP_OVERSIZE: The maximum number of bytes that tcp_write may
   * allocate ahead of time in an attempt to create shorter pbuf chains
   * for transmission. The meaningful range is 0 to TCP_MSS. Some
   * suggested values are:
   *
   * 0:         Disable oversized allocation. Each tcp_write() allocates a new
                pbuf (old behaviour).
   * 1:         Allocate size-aligned pbufs with minimal excess. Use this if your
   *            scatter-gather DMA requires aligned fragments.
   * 128:       Limit the pbuf/memory overhead to 20%.
   * TCP_MSS:   Try to create unfragmented TCP packets.
   * TCP_MSS/4: Try to create 4 fragments or less per TCP packet.
   */
  #define TCP_OVERSIZE                    TCP_MSS
  //#if 0
  /**
   * LWIP_NETIF_HOSTNAME==1: use DHCP_OPTION_HOSTNAME with netif's hostname
   * field.
   */
  #define LWIP_NETIF_HOSTNAME             0
  
  /**
   * LWIP_NETIF_STATUS_CALLBACK==1: Support a callback function whenever an interface
   * changes its up/down status (i.e., due to DHCP IP acquisition)
   */
  #define LWIP_NETIF_STATUS_CALLBACK      0
  
  /**
   * LWIP_NETIF_REMOVE_CALLBACK==1: Support a callback function that is called
   * when a netif has been removed
   */
  #define LWIP_NETIF_REMOVE_CALLBACK      1
  //#if 0
  /**
   * LWIP_NETIF_TX_SINGLE_PBUF: if this is set to 1, lwIP tries to put all data
   * to be sent into one single pbuf. This is for compatibility with DMA-enabled
   * MACs that do not support scatter-gather.
   * Beware that this might involve CPU-memcpy before transmitting that would not
   * be needed without this flag! Use this only if you need to!
   *
   * @todo: TCP and IP-frag do not work with this, yet:
   */
  //#define LWIP_NETIF_TX_SINGLE_PBUF             1//clyu http can't connect
  //#if 0
  /**
   * TCPIP_THREAD_STACKSIZE: The stack size used by the main tcpip thread.
   * The stack size value itself is platform-dependent, but is passed to
   * sys_thread_new() when the thread is created.
   */
  //#define TCPIP_THREAD_STACKSIZE          250//clyu
  
  /**
   * TCPIP_THREAD_PRIO: The priority assigned to the main tcpip thread.
   * The priority value itself is platform-dependent, but is passed to
   * sys_thread_new() when the thread is created.
   */
  //#define TCPIP_THREAD_PRIO               1//clyu
  
  /**
   * TCPIP_MBOX_SIZE: The mailbox size for the tcpip thread messages
   * The queue size value itself is platform-dependent, but is passed to
   * sys_mbox_new() when tcpip_init is called.
   */
  //#define TCPIP_MBOX_SIZE                 15
  //#if 0
  /**
   * Define this to something that triggers a watchdog. This is called from
   * tcpip_thread after processing a message.
   */
  #define LWIP_TCPIP_THREAD_ALIVE()
  
  /**
   * DEFAULT_UDP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a
   * NETCONN_UDP. The queue size value itself is platform-dependent, but is passed
   * to sys_mbox_new() when the recvmbox is created.
   */
  //#define DEFAULT_UDP_RECVMBOX_SIZE       4//clyu
  
  /**
   * DEFAULT_TCP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a
   * NETCONN_TCP. The queue size value itself is platform-dependent, but is passed
   * to sys_mbox_new() when the recvmbox is created.
   */
  //#define DEFAULT_TCP_RECVMBOX_SIZE       4//clyu
  
  /**
   * DEFAULT_ACCEPTMBOX_SIZE: The mailbox size for the incoming connections.
   * The queue size value itself is platform-dependent, but is passed to
   * sys_mbox_new() when the acceptmbox is created.
   */
  //#define DEFAULT_ACCEPTMBOX_SIZE         2//clyu
  
  /** LWIP_NETCONN_SEM_PER_THREAD==1: Use one (thread-local) semaphore per
   * thread calling socket/netconn functions instead of allocating one
   * semaphore per netconn (and per select etc.)
   * ATTENTION: a thread-local semaphore for API calls is needed:
   * - LWIP_NETCONN_THREAD_SEM_GET() returning a sys_sem_t*
   * - LWIP_NETCONN_THREAD_SEM_ALLOC() creating the semaphore
   * - LWIP_NETCONN_THREAD_SEM_FREE() freeing the semaphore
   * The latter 2 can be invoked up by calling netconn_thread_init()/netconn_thread_cleanup().
   * Ports may call these for threads created with sys_thread_new().
   */
  #define LWIP_NETCONN_SEM_PER_THREAD     0
  
  /** LWIP_NETCONN_FULLDUPLEX==1: Enable code that allows reading from one thread,
   * writing from a 2nd thread and closing from a 3rd thread at the same time.
   * ATTENTION: This is currently really alpha! Some requirements:
   * - LWIP_NETCONN_SEM_PER_THREAD==1 is required to use one socket/netconn from
   *   multiple threads at once
   * - sys_mbox_free() has to unblock receive tasks waiting on recvmbox/acceptmbox
   *   and prevent a task pending on this during/after deletion
   */
  #define LWIP_NETCONN_FULLDUPLEX         0
  
  /**
   * LWIP_TCP_KEEPALIVE==1: Enable TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT
   * options processing. Note that TCP_KEEPIDLE and TCP_KEEPINTVL have to be set
   * in seconds. (does not require sockets.c, and will affect tcp.c)
   */
  #define LWIP_TCP_KEEPALIVE              0
  
  /**
   * LWIP_SO_SNDTIMEO==1: Enable send timeout for sockets/netconns and
   * SO_SNDTIMEO processing.
   */
  #define LWIP_SO_SNDTIMEO                0
  
  /**
   * LWIP_SO_RCVTIMEO==1: Enable receive timeout for sockets/netconns and
   * SO_RCVTIMEO processing.
   */
  //#define LWIP_SO_RCVTIMEO                1//clyu
  //#if 0
  /**
   * By default, TCP socket/netconn close waits 20 seconds max to send the FIN
   */
  #define LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT 20000
  //#if 0
  /**
   * LWIP_STATS==1: Enable statistics collection in lwip_stats.
   */
  #define LWIP_STATS                      0
  
  /**
   * LWIP_CHECKSUM_CTRL_PER_NETIF==1: Checksum generation/check can be enabled/disabled
   * per netif.
   * ATTENTION: if enabled, the CHECKSUM_GEN_* and CHECKSUM_CHECK_* defines must be enabled!
   */
  #define LWIP_CHECKSUM_CTRL_PER_NETIF    1
  #if 1
  /**
   * PPP_SUPPORT==1: Enable PPP. Check doc/ppp.txt to understand the implementation
   */
  #define PPP_SUPPORT                     0
  
  /**
   * PPP_INPROC_IRQ_SAFE==1 call pppos_input() using tcpip_callback().
   *
   * Please read the "PPPoS input path" chapter in the PPP documentation about this option.
   */
  #define PPP_INPROC_IRQ_SAFE             0
  
  /**
   * PPP_NOTIFY_PHASE==1: Support PPP notify phase support
   *
   * PPP notify phase support allows you to set a callback which is
   * called on change of the internal PPP state machine.
   *
   * This can be used for example to set a LED pattern depending on the
   * current phase of the PPP session.
   */
  //#define PPP_NOTIFY_PHASE                1//clyu ping time 1800ms
  #endif
  /**
   * MSCHAP_SUPPORT==1: Support MSCHAP.
   */
  #define MSCHAP_SUPPORT                  0
  
  /**
   * EAP_SUPPORT==1: Support EAP.
   */
  #define EAP_SUPPORT                     0
  
  /**
   * MPPE_SUPPORT==1: Support MPPE.
   */
  #define MPPE_SUPPORT                    0
  
  /**
   * LWIP_USE_EXTERNAL_POLARSSL: Use external PolarSSL library
   */
  #define LWIP_USE_EXTERNAL_POLARSSL      0
  
  /**
   * LWIP_USE_EXTERNAL_MBEDTLS: Use external mbed TLS library
   */
  #define LWIP_USE_EXTERNAL_MBEDTLS       0
  
  /**
   * LCP_ECHOINTERVAL: Interval in seconds between keepalive echo requests, 0 to disable.
   */
  #define LCP_ECHOINTERVAL                0
  
  /**
   * PPP_MAXIDLEFLAG: Max Xmit idle time (in ms) before resend flag char.
   */
  #define PPP_MAXIDLEFLAG                 100
  
  /**
   * MAXNAMELEN: max length of hostname or name for auth
   */
  #define MAXNAMELEN                      64
  
  /**
   * MAXSECRETLEN: max length of password or secret
   */
  #define MAXSECRETLEN                    64
  
  
  #include "FreeRTOS.h"
  #define mem_clib_free vPortFree
  #define mem_clib_malloc pvPortMalloc
  #define mem_clib_calloc(x, y) pvPortMalloc(x * y)
  
  
  
  #endif
  