espconn.h File Reference

#include "lwip/dns.h"
#include "os_type.h"

Include dependency graph for espconn.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	_esp_tcp
struct	_esp_udp
struct	_remot_info
struct	espconn
struct	espconn_packet
struct	_espconn_buf
struct	_comon_pkt
struct	_espconn_msg
struct	mdns_info

Macros
#define	espconn_printf(fmt, args...)
#define	ESPCONN_OK   0 /* No error, everything OK. */
#define	ESPCONN_MEM   -1 /* Out of memory error. */
#define	ESPCONN_TIMEOUT   -3 /* Timeout. */
#define	ESPCONN_RTE   -4 /* Routing problem. */
#define	ESPCONN_INPROGRESS   -5 /* Operation in progress */
#define	ESPCONN_MAXNUM   -7 /* Total number exceeds the set maximum*/
#define	ESPCONN_ABRT   -8 /* Connection aborted. */
#define	ESPCONN_RST   -9 /* Connection reset. */
#define	ESPCONN_CLSD   -10 /* Connection closed. */
#define	ESPCONN_CONN   -11 /* Not connected. */
#define	ESPCONN_ARG   -12 /* Illegal argument. */
#define	ESPCONN_IF   -14 /* Low_level error */
#define	ESPCONN_ISCONN   -15 /* Already connected. */
#define	ESPCONN_HANDSHAKE   -28 /* ssl handshake failed */
#define	ESPCONN_RESP_TIMEOUT   -29 /* ssl handshake no response*/
#define	ESPCONN_PROTO_MSG   -61 /* ssl application invalid */
#define	ESPCONN_SSL   0x01
#define	ESPCONN_NORM   0x00
#define	ESPCONN_STA   0x01
#define	ESPCONN_AP   0x02
#define	ESPCONN_AP_STA   0x03
#define	STA_NETIF   0x00
#define	AP_NETIF   0x01
#define	_MDNS_INFO
#define	linkMax   15
#define	espconn_delay_disabled(espconn)   (((espconn)->pcommon.espconn_opt & ESPCONN_NODELAY) != 0)
#define	espconn_delay_enabled(espconn)   (((espconn)->pcommon.espconn_opt & ESPCONN_NODELAY) == 0)
#define	espconn_reuse_disabled(espconn)   (((espconn)->pcommon.espconn_opt & ESPCONN_REUSEADDR) != 0)
#define	espconn_copy_disabled(espconn)   (((espconn)->pcommon.espconn_opt & ESPCONN_COPY) != 0)
#define	espconn_copy_enabled(espconn)   (((espconn)->pcommon.espconn_opt & ESPCONN_COPY) == 0)
#define	espconn_keepalive_disabled(espconn)   (((espconn)->pcommon.espconn_opt & ESPCONN_KEEPALIVE) != 0)
#define	espconn_keepalive_enabled(espconn)   (((espconn)->pcommon.espconn_opt & ESPCONN_KEEPALIVE) == 0)
#define	espconn_TaskPrio   26
#define	espconn_TaskQueueLen   15

Typedefs
typedef void *	espconn_handle
typedef void(*	espconn_connect_callback) (void *arg)
typedef void(*	espconn_reconnect_callback) (void *arg, sint8 err)
typedef struct _esp_tcp	esp_tcp
typedef struct _esp_udp	esp_udp
typedef struct _remot_info	remot_info
typedef void(*	espconn_recv_callback) (void *arg, char *pdata, unsigned short len)
typedef void(*	espconn_sent_callback) (void *arg)
typedef struct _espconn_buf	espconn_buf
typedef struct _comon_pkt	comon_pkt
typedef struct _espconn_msg	espconn_msg

Enumerations
enum	espconn_type {   ESPCONN_INVALID = 0, ESPCONN_TCP = 0x10, ESPCONN_UDP = 0x20, ESPCONN_INVALID = 0,   ESPCONN_TCP = 0x10, ESPCONN_UDP = 0x20 }
enum	espconn_state {   ESPCONN_NONE, ESPCONN_WAIT, ESPCONN_LISTEN, ESPCONN_CONNECT,   ESPCONN_WRITE, ESPCONN_READ, ESPCONN_CLOSE, ESPCONN_NONE,   ESPCONN_WAIT, ESPCONN_LISTEN, ESPCONN_CONNECT, ESPCONN_WRITE,   ESPCONN_READ, ESPCONN_CLOSE }
enum	espconn_option {   ESPCONN_START = 0x00, ESPCONN_REUSEADDR = 0x01, ESPCONN_NODELAY = 0x02, ESPCONN_COPY = 0x04,   ESPCONN_KEEPALIVE = 0x08, ESPCONN_END, ESPCONN_START = 0x00, ESPCONN_REUSEADDR = 0x01,   ESPCONN_NODELAY = 0x02, ESPCONN_COPY = 0x04, ESPCONN_KEEPALIVE = 0x08, ESPCONN_END }
enum	espconn_level {   ESPCONN_KEEPIDLE, ESPCONN_KEEPINTVL, ESPCONN_KEEPCNT, ESPCONN_KEEPIDLE,   ESPCONN_KEEPINTVL, ESPCONN_KEEPCNT }
enum	espconn_sig {   SIG_ESPCONN_NONE, SIG_ESPCONN_ERRER, SIG_ESPCONN_LISTEN, SIG_ESPCONN_CONNECT,   SIG_ESPCONN_WRITE, SIG_ESPCONN_SEND, SIG_ESPCONN_READ, SIG_ESPCONN_CLOSE }

Functions
void	espconn_copy_partial (struct espconn *pesp_dest, struct espconn *pesp_source)
void	espconn_list_creat (espconn_msg **phead, espconn_msg *pinsert)
void	espconn_list_delete (espconn_msg **phead, espconn_msg *pdelete)
bool	espconn_find_connection (struct espconn *pespconn, espconn_msg **pnode)
sint8	espconn_get_connection_info (struct espconn *pespconn, remot_info **pcon_info, uint8 typeflags)
sint8	espconn_get_packet_info (struct espconn *espconn, struct espconn_packet *infoarg)
sint8	espconn_connect (struct espconn *espconn)
sint8	espconn_disconnect (struct espconn *espconn)
sint8	espconn_delete (struct espconn *espconn)
sint8	espconn_accept (struct espconn *espconn)
sint8	espconn_create (struct espconn *espconn)
uint8	espconn_tcp_get_wnd (void)
sint8	espconn_tcp_set_wnd (uint8 num)
uint8	espconn_tcp_get_max_con (void)
sint8	espconn_tcp_set_max_con (uint8 num)
uint8	espconn_tcp_get_max_retran (void)
sint8	espconn_tcp_set_max_retran (uint8 num)
uint8	espconn_tcp_get_max_syn (void)
sint8	espconn_tcp_set_max_syn (uint8 num)
sint8	espconn_tcp_get_max_con_allow (struct espconn *espconn)
sint8	espconn_tcp_set_max_con_allow (struct espconn *espconn, uint8 num)
sint8	espconn_tcp_set_buf_count (struct espconn *espconn, uint8 num)
sint8	espconn_regist_time (struct espconn *espconn, uint32 interval, uint8 type_flag)
sint8	espconn_regist_sentcb (struct espconn *espconn, espconn_sent_callback sent_cb)
sint8	espconn_regist_write_finish (struct espconn *espconn, espconn_connect_callback write_finish_fn)
sint8	espconn_sent (struct espconn *espconn, uint8 *psent, uint16 length)
sint8	espconn_regist_connectcb (struct espconn *espconn, espconn_connect_callback connect_cb)
sint8	espconn_regist_recvcb (struct espconn *espconn, espconn_recv_callback recv_cb)
sint8	espconn_regist_reconcb (struct espconn *espconn, espconn_reconnect_callback recon_cb)
sint8	espconn_regist_disconcb (struct espconn *espconn, espconn_connect_callback discon_cb)
uint32	espconn_port (void)
sint8	espconn_set_opt (struct espconn *espconn, uint8 opt)
sint8	espconn_set_keepalive (struct espconn *espconn, uint8 level, void *optarg)
sint8	espconn_get_keepalive (struct espconn *espconn, uint8 level, void *optarg)
sint8	espconn_gethostbyname (struct espconn *pespconn, const char *name, ip_addr_t *addr, dns_found_callback found)
sint8	espconn_igmp_join (ip_addr_t *host_ip, ip_addr_t *multicast_ip)
sint8	espconn_igmp_leave (ip_addr_t *host_ip, ip_addr_t *multicast_ip)
void	espconn_mdns_init (struct mdns_info *info)
void	espconn_mdns_close (void)
void	espconn_mdns_server_register (void)
void	espconn_mdns_server_unregister (void)
char *	espconn_mdns_get_servername (void)
void	espconn_mdns_set_servername (const char *name)
void	espconn_mdns_set_hostname (char *name)
char *	espconn_mdns_get_hostname (void)
void	espconn_mdns_disable (void)
void	espconn_mdns_enable (void)
void	espconn_dns_setserver (u8_t numdns, ip_addr_t *dnsserver)

Macro Definition Documentation

_MDNS_INFO

#define _MDNS_INFO

Definition at line 183 of file espconn.h.

AP_NETIF

#define AP_NETIF   0x01

Definition at line 48 of file espconn.h.

Referenced by espconn_connect().

ESPCONN_ABRT

#define ESPCONN_ABRT   -8 /* Connection aborted. */

Definition at line 27 of file espconn.h.

ESPCONN_AP

#define ESPCONN_AP   0x02

Definition at line 44 of file espconn.h.

Referenced by espconn_connect().

ESPCONN_AP_STA

#define ESPCONN_AP_STA   0x03

Definition at line 45 of file espconn.h.

Referenced by espconn_connect(), espconn_udp_sendto(), and espconn_udp_sent().

ESPCONN_ARG

#define ESPCONN_ARG   -12 /* Illegal argument. */

Definition at line 32 of file espconn.h.

Referenced by espconn_abort(), espconn_accept(), espconn_clear_opt(), espconn_connect(), espconn_create(), espconn_delete(), espconn_disconnect(), espconn_get_connection_info(), espconn_get_keepalive(), espconn_get_packet_info(), espconn_recv_hold(), espconn_recv_unhold(), espconn_regist_connectcb(), espconn_regist_disconcb(), espconn_regist_reconcb(), espconn_regist_recvcb(), espconn_regist_sentcb(), espconn_regist_time(), espconn_regist_write_finish(), espconn_sendto(), espconn_sent(), espconn_set_keepalive(), espconn_set_opt(), espconn_tcp_delete(), espconn_tcp_get_max_con_allow(), espconn_tcp_sent(), espconn_tcp_set_buf_count(), espconn_tcp_set_max_con(), espconn_tcp_set_max_con_allow(), espconn_tcp_set_max_retran(), espconn_tcp_set_max_syn(), espconn_tcp_set_wnd(), espconn_udp_sendto(), and espconn_udp_sent().

ESPCONN_CLSD

#define ESPCONN_CLSD   -10 /* Connection closed. */

Definition at line 29 of file espconn.h.

Referenced by espconn_client_err(), and esponn_server_err().

ESPCONN_CONN

#define ESPCONN_CONN   -11 /* Not connected. */

Definition at line 30 of file espconn.h.

Referenced by espconn_client_err(), and esponn_server_err().

espconn_copy_disabled

#define espconn_copy_disabled

(

espconn

)

(((espconn)->pcommon.espconn_opt & ESPCONN_COPY) != 0)

Definition at line 198 of file espconn.h.

Referenced by espconn_sent(), and espconn_tcp_sent().

espconn_copy_enabled

#define espconn_copy_enabled

(

espconn

)

(((espconn)->pcommon.espconn_opt & ESPCONN_COPY) == 0)

Definition at line 199 of file espconn.h.

Referenced by espconn_sent().

espconn_delay_disabled

#define espconn_delay_disabled

(

espconn

)

(((espconn)->pcommon.espconn_opt & ESPCONN_NODELAY) != 0)

Definition at line 195 of file espconn.h.

Referenced by espconn_set_opt().

espconn_delay_enabled

#define espconn_delay_enabled

(

espconn

)

(((espconn)->pcommon.espconn_opt & ESPCONN_NODELAY) == 0)

Definition at line 196 of file espconn.h.

Referenced by espconn_clear_opt().

ESPCONN_HANDSHAKE

#define ESPCONN_HANDSHAKE   -28 /* ssl handshake failed */

Definition at line 36 of file espconn.h.

ESPCONN_IF

#define ESPCONN_IF   -14 /* Low_level error */

Definition at line 33 of file espconn.h.

Referenced by espconn_udp_sendto(), and espconn_udp_sent().

ESPCONN_INPROGRESS

#define ESPCONN_INPROGRESS   -5 /* Operation in progress */

Definition at line 24 of file espconn.h.

Referenced by espconn_abort(), espconn_disconnect(), and espconn_tcp_delete().

ESPCONN_ISCONN

#define ESPCONN_ISCONN   -15 /* Already connected. */

Definition at line 34 of file espconn.h.

Referenced by espconn_accept(), espconn_connect(), and espconn_create().

espconn_keepalive_disabled

#define espconn_keepalive_disabled

(

espconn

)

(((espconn)->pcommon.espconn_opt & ESPCONN_KEEPALIVE) != 0)

Definition at line 200 of file espconn.h.

Referenced by espconn_client_connect(), espconn_get_keepalive(), espconn_set_keepalive(), espconn_set_opt(), and espconn_tcp_accept().

espconn_keepalive_enabled

#define espconn_keepalive_enabled

(

espconn

)

(((espconn)->pcommon.espconn_opt & ESPCONN_KEEPALIVE) == 0)

Definition at line 201 of file espconn.h.

Referenced by espconn_clear_opt().

ESPCONN_MAXNUM

#define ESPCONN_MAXNUM   -7 /* Total number exceeds the set maximum*/

Definition at line 25 of file espconn.h.

Referenced by espconn_sent().

ESPCONN_MEM

#define ESPCONN_MEM   -1 /* Out of memory error. */

Definition at line 21 of file espconn.h.

Referenced by espconn_sent(), espconn_tcp_client(), espconn_tcp_server(), espconn_tcp_write(), espconn_udp_sendto(), espconn_udp_sent(), and espconn_udp_server().

ESPCONN_NORM

#define ESPCONN_NORM   0x00

Definition at line 41 of file espconn.h.

ESPCONN_OK

#define ESPCONN_OK   0 /* No error, everything OK. */

Definition at line 20 of file espconn.h.

Referenced by captdnsRecv(), espconn_abort(), espconn_accept(), espconn_clear_opt(), espconn_connect(), espconn_create(), espconn_delete(), espconn_disconnect(), espconn_get_connection_info(), espconn_get_keepalive(), espconn_get_packet_info(), espconn_igmp_join(), espconn_igmp_leave(), espconn_recv_hold(), espconn_recv_unhold(), espconn_regist_connectcb(), espconn_regist_disconcb(), espconn_regist_reconcb(), espconn_regist_recvcb(), espconn_regist_sentcb(), espconn_regist_time(), espconn_regist_write_finish(), espconn_sendto(), espconn_sent(), espconn_set_keepalive(), espconn_set_opt(), espconn_tcp_server(), espconn_tcp_set_buf_count(), espconn_tcp_set_max_con(), espconn_tcp_set_max_con_allow(), espconn_tcp_set_max_retran(), espconn_tcp_set_max_syn(), espconn_tcp_set_wnd(), espconn_udp_server(), and mqtt_send_keepalive().

espconn_printf

#define espconn_printf	(		fmt,
			args...
	)

Definition at line 10 of file espconn.h.

Referenced by espconn_client_connect(), espconn_client_err(), espconn_connect(), espconn_server_poll(), espconn_server_recv(), espconn_tcp_accept(), espconn_tcp_delete(), espconn_tcp_disconnect(), espconn_tcp_disconnect_successful(), espconn_tcp_reconnect(), and espconn_tcp_sent().

ESPCONN_PROTO_MSG

#define ESPCONN_PROTO_MSG   -61 /* ssl application invalid */

Definition at line 38 of file espconn.h.

ESPCONN_RESP_TIMEOUT

#define ESPCONN_RESP_TIMEOUT   -29 /* ssl handshake no response*/

Definition at line 37 of file espconn.h.

espconn_reuse_disabled

#define espconn_reuse_disabled

(

espconn

)

(((espconn)->pcommon.espconn_opt & ESPCONN_REUSEADDR) != 0)

Definition at line 197 of file espconn.h.

Referenced by espconn_tcp_disconnect_successful().

ESPCONN_RST

#define ESPCONN_RST   -9 /* Connection reset. */

Definition at line 28 of file espconn.h.

ESPCONN_RTE

#define ESPCONN_RTE   -4 /* Routing problem. */

Definition at line 23 of file espconn.h.

Referenced by espconn_connect(), espconn_tcp_client(), espconn_udp_sendto(), and espconn_udp_sent().

ESPCONN_SSL

#define ESPCONN_SSL   0x01

Definition at line 40 of file espconn.h.

ESPCONN_STA

#define ESPCONN_STA   0x01

Definition at line 43 of file espconn.h.

Referenced by espconn_connect().

espconn_TaskPrio

#define espconn_TaskPrio   26

Definition at line 203 of file espconn.h.

Referenced by espconn_client_close(), espconn_client_err(), espconn_init(), espconn_server_close(), espconn_tcp_sent(), and esponn_server_err().

espconn_TaskQueueLen

#define espconn_TaskQueueLen   15

Definition at line 204 of file espconn.h.

Referenced by espconn_init().

ESPCONN_TIMEOUT

#define ESPCONN_TIMEOUT   -3 /* Timeout. */

Definition at line 22 of file espconn.h.

Referenced by espconn_client_err(), and esponn_server_err().

linkMax

#define linkMax   15

Definition at line 193 of file espconn.h.

Referenced by espconn_tcp_set_max_con(), and espconn_tcp_set_wnd().

STA_NETIF

#define STA_NETIF   0x00

Definition at line 47 of file espconn.h.

Referenced by espconn_connect().

Typedef Documentation

comon_pkt

typedef struct _comon_pkt comon_pkt

esp_tcp

typedef struct _esp_tcp esp_tcp

esp_udp

typedef struct _esp_udp esp_udp

espconn_buf

typedef struct _espconn_buf espconn_buf

espconn_connect_callback

typedef void(* espconn_connect_callback) (void *arg)

Definition at line 15 of file espconn.h.

espconn_handle

typedef void* espconn_handle

Definition at line 14 of file espconn.h.

espconn_msg

typedef struct _espconn_msg espconn_msg

espconn_reconnect_callback

typedef void(* espconn_reconnect_callback) (void *arg, sint8 err)

Definition at line 16 of file espconn.h.

espconn_recv_callback

typedef void(* espconn_recv_callback) (void *arg, char *pdata, unsigned short len)

A callback prototype to inform about events for a espconn

Definition at line 95 of file espconn.h.

espconn_sent_callback

typedef void(* espconn_sent_callback) (void *arg)

Definition at line 96 of file espconn.h.

remot_info

typedef struct _remot_info remot_info

Enumeration Type Documentation

espconn_level

enum espconn_level

Enumerator
ESPCONN_KEEPIDLE
ESPCONN_KEEPINTVL
ESPCONN_KEEPCNT
ESPCONN_KEEPIDLE
ESPCONN_KEEPINTVL
ESPCONN_KEEPCNT

Definition at line 124 of file espconn.h.

                  {
    ESPCONN_KEEPIDLE,
    ESPCONN_KEEPINTVL,
    ESPCONN_KEEPCNT
};

espconn_option

enum espconn_option

Enumerator
ESPCONN_START
ESPCONN_REUSEADDR
ESPCONN_NODELAY
ESPCONN_COPY
ESPCONN_KEEPALIVE
ESPCONN_END
ESPCONN_START
ESPCONN_REUSEADDR
ESPCONN_NODELAY
ESPCONN_COPY
ESPCONN_KEEPALIVE
ESPCONN_END

Definition at line 115 of file espconn.h.

                   {
    ESPCONN_START = 0x00,
    ESPCONN_REUSEADDR = 0x01,
    ESPCONN_NODELAY = 0x02,
    ESPCONN_COPY = 0x04,
    ESPCONN_KEEPALIVE = 0x08,
    ESPCONN_END
};

espconn_sig

enum espconn_sig

Enumerator
SIG_ESPCONN_NONE
SIG_ESPCONN_ERRER
SIG_ESPCONN_LISTEN
SIG_ESPCONN_CONNECT
SIG_ESPCONN_WRITE
SIG_ESPCONN_SEND
SIG_ESPCONN_READ
SIG_ESPCONN_CLOSE

Definition at line 206 of file espconn.h.

                 {
    SIG_ESPCONN_NONE,
    SIG_ESPCONN_ERRER,
    SIG_ESPCONN_LISTEN,
    SIG_ESPCONN_CONNECT,
    SIG_ESPCONN_WRITE,
    SIG_ESPCONN_SEND,
    SIG_ESPCONN_READ,
    SIG_ESPCONN_CLOSE
};

espconn_state

enum espconn_state

Current state of the espconn. Non-TCP espconn are always in state ESPCONN_NONE!

Enumerator
ESPCONN_NONE
ESPCONN_WAIT
ESPCONN_LISTEN
ESPCONN_CONNECT
ESPCONN_WRITE
ESPCONN_READ
ESPCONN_CLOSE
ESPCONN_NONE
ESPCONN_WAIT
ESPCONN_LISTEN
ESPCONN_CONNECT
ESPCONN_WRITE
ESPCONN_READ
ESPCONN_CLOSE

Definition at line 60 of file espconn.h.

                   {
    ESPCONN_NONE,
    ESPCONN_WAIT,
    ESPCONN_LISTEN,
    ESPCONN_CONNECT,
    ESPCONN_WRITE,
    ESPCONN_READ,
    ESPCONN_CLOSE
};

espconn_type

enum espconn_type

Protocol family and type of the espconn

Enumerator
ESPCONN_INVALID
ESPCONN_TCP
ESPCONN_UDP
ESPCONN_INVALID
ESPCONN_TCP
ESPCONN_UDP

Definition at line 51 of file espconn.h.

                  {
    ESPCONN_INVALID    = 0,
    /* ESPCONN_TCP Group */
    ESPCONN_TCP        = 0x10,
    /* ESPCONN_UDP Group */
    ESPCONN_UDP        = 0x20,
};

Function Documentation

espconn_accept()

sint8 espconn_accept

(

struct espconn *

espconn

)

Definition at line 875 of file espconn.c.

Referenced by httpdInit().

{
    sint8 value = ESPCONN_OK;
    espconn_msg *plist = NULL;

    if (espconn == NULL) {
        return ESPCONN_ARG;
    } else if (espconn ->type != ESPCONN_TCP)
        return ESPCONN_ARG;

    /*check the active node information whether is the same as the entity or not*/
    for (plist = plink_active; plist != NULL; plist = plist->pnext){
        if (plist->pespconn && plist->pespconn->type == ESPCONN_TCP){
            if (espconn->proto.tcp->local_port == plist->pespconn->proto.tcp->local_port){
                return ESPCONN_ISCONN;
            }
        }
    }
    value = espconn_tcp_server(espconn);

    return value;
}

Here is the caller graph for this function:

espconn_connect()

sint8 espconn_connect

(

struct espconn *

espconn

)

Definition at line 260 of file espconn.c.

Referenced by MQTT_Connect(), and mqtt_dns_found().

{
    struct ip_addr ipaddr;
    struct ip_info ipinfo;
    uint8 connect_status = 0;
    sint8 value = ESPCONN_OK;
    espconn_msg *plist = NULL;
    remot_info *pinfo = NULL;

    if (espconn == NULL) {
        return ESPCONN_ARG;
    } else if (espconn ->type != ESPCONN_TCP)
        return ESPCONN_ARG;

    /*Check the active node count whether is the limit or not*/
    if (espconn_get_acticve_num(ESPCONN_TCP) >= espconn_tcp_get_max_con())
        return ESPCONN_ISCONN;

    /*Check the IP address whether is zero or not in different mode*/
    if (wifi_get_opmode() == ESPCONN_STA){
        wifi_get_ip_info(STA_NETIF,&ipinfo);
        if (ipinfo.ip.addr == 0){
            return ESPCONN_RTE;
        }
    } else if(wifi_get_opmode() == ESPCONN_AP){
        wifi_get_ip_info(AP_NETIF,&ipinfo);
        if (ipinfo.ip.addr == 0){
            return ESPCONN_RTE;
        }
    } else if(wifi_get_opmode() == ESPCONN_AP_STA){
        IP4_ADDR(&ipaddr, espconn->proto.tcp->remote_ip[0],
                            espconn->proto.tcp->remote_ip[1],
                            espconn->proto.tcp->remote_ip[2],
                            espconn->proto.tcp->remote_ip[3]);
        ipaddr.addr <<= 8;
        wifi_get_ip_info(AP_NETIF,&ipinfo);
        ipinfo.ip.addr <<= 8;
        espconn_printf("softap_addr = %x, remote_addr = %x\n", ipinfo.ip.addr, ipaddr.addr);

        if (ipaddr.addr != ipinfo.ip.addr){
            connect_status = wifi_station_get_connect_status();
            if (connect_status == STATION_GOT_IP){
                wifi_get_ip_info(STA_NETIF,&ipinfo);
                if (ipinfo.ip.addr == 0)
                    return ESPCONN_RTE;
            } else if (connect_status == STATION_IDLE){
                return ESPCONN_RTE;
            } else {
                return connect_status;
            }
        }
    }

    /*check the active node information whether is the same as the entity or not*/
    for (plist = plink_active; plist != NULL; plist = plist->pnext){
        if (plist->pespconn && plist->pespconn->type == ESPCONN_TCP){
            if (espconn->proto.tcp->local_port == plist->pespconn->proto.tcp->local_port){
                return ESPCONN_ISCONN;
            }
        }
    }

    value = espconn_tcp_client(espconn);

    return value;
}

Here is the caller graph for this function:

espconn_copy_partial()

void espconn_copy_partial	(	struct espconn *	pesp_dest,
		struct espconn *	pesp_source
	)

Definition at line 46 of file espconn.c.

References _esp_tcp::connect_callback, _esp_tcp::disconnect_callback, ESPCONN_TCP, espconn::link_cnt, _esp_tcp::local_ip, _esp_udp::local_ip, _esp_tcp::local_port, _esp_udp::local_port, os_memcpy, espconn::proto, _esp_tcp::reconnect_callback, espconn::recv_callback, _esp_tcp::remote_ip, _esp_udp::remote_ip, _esp_tcp::remote_port, _esp_udp::remote_port, espconn::reverse, espconn::sent_callback, espconn::state, espconn::tcp, espconn::type, and espconn::udp.

Referenced by espconn_tcp_accept(), espconn_tcp_disconnect_successful(), and espconn_tcp_reconnect().

{
    pesp_dest->type = pesp_source->type;
    pesp_dest->state = pesp_source->state;
    if (pesp_source->type == ESPCONN_TCP){
        pesp_dest->proto.tcp->remote_port = pesp_source->proto.tcp->remote_port;
        pesp_dest->proto.tcp->local_port = pesp_source->proto.tcp->local_port;
        os_memcpy(pesp_dest->proto.tcp->remote_ip, pesp_source->proto.tcp->remote_ip, 4);
        os_memcpy(pesp_dest->proto.tcp->local_ip, pesp_source->proto.tcp->local_ip, 4);
        pesp_dest->proto.tcp->connect_callback = pesp_source->proto.tcp->connect_callback;
        pesp_dest->proto.tcp->reconnect_callback = pesp_source->proto.tcp->reconnect_callback;
        pesp_dest->proto.tcp->disconnect_callback = pesp_source->proto.tcp->disconnect_callback;
    } else {
        pesp_dest->proto.udp->remote_port = pesp_source->proto.udp->remote_port;
        pesp_dest->proto.udp->local_port = pesp_source->proto.udp->local_port;
        os_memcpy(pesp_dest->proto.udp->remote_ip, pesp_source->proto.udp->remote_ip, 4);
        os_memcpy(pesp_dest->proto.udp->local_ip, pesp_source->proto.udp->local_ip, 4);
    }
    pesp_dest->recv_callback = pesp_source->recv_callback;
    pesp_dest->sent_callback = pesp_source->sent_callback;
    pesp_dest->link_cnt = pesp_source->link_cnt;
    pesp_dest->reverse = pesp_source->reverse;
}

Here is the caller graph for this function:

espconn_create()

sint8 espconn_create

(

struct espconn *

espconn

)

Definition at line 334 of file espconn.c.

Referenced by captdnsInit().

{
    sint8 value = ESPCONN_OK;
    espconn_msg *plist = NULL;

    if (espconn == NULL) {
        return ESPCONN_ARG;
    } else if (espconn ->type != ESPCONN_UDP){
        return ESPCONN_ARG;
    }

    /*check the active node information whether is the same as the entity or not*/
    for (plist = plink_active; plist != NULL; plist = plist->pnext){
        if (plist->pespconn && plist->pespconn->type == ESPCONN_UDP){
            if (espconn->proto.udp->local_port == plist->pespconn->proto.udp->local_port){
                return ESPCONN_ISCONN;
            }
        }
    }

    value = espconn_udp_server(espconn);

    return value;
}

Here is the caller graph for this function:

espconn_delete()

sint8 espconn_delete

(

struct espconn *

espconn

)

Definition at line 1217 of file espconn.c.

Referenced by captdnsStop(), httpdStop(), and mqtt_tcpclient_delete().

{
    espconn_msg *pnode = NULL;
    bool value = false;

    if (espconn == NULL) {
        return ESPCONN_ARG;
    } else if (espconn ->type != ESPCONN_UDP)
        return espconn_tcp_delete(espconn);

    /*Find the node depend on the espconn message*/
    value = espconn_find_connection(espconn, &pnode);

    if (value){
        espconn_udp_disconnect(pnode);
        return ESPCONN_OK;
    } else
        return ESPCONN_ARG;
}

Here is the caller graph for this function:

espconn_disconnect()

sint8 espconn_disconnect

(

struct espconn *

espconn

)

Definition at line 942 of file espconn.c.

Referenced by httpdConnectCb(), httpdSentCb(), httpdStop(), MQTT_Task(), and mqtt_tcpclient_recv().

{
    espconn_msg *pnode = NULL;
    bool value = false;

    if (espconn == NULL) {
        return ESPCONN_ARG;;
    } else if (espconn ->type != ESPCONN_TCP)
        return ESPCONN_ARG;

    /*Find the node depend on the espconn message*/
    value = espconn_find_connection(espconn, &pnode);

    if (value){
        /*protect for redisconnection*/
        if (espconn->state == ESPCONN_CLOSE)
            return ESPCONN_INPROGRESS;
        espconn_tcp_disconnect(pnode,0);    //1 force, 0 normal
        return ESPCONN_OK;
    } else
        return ESPCONN_ARG;
}

Here is the caller graph for this function:

espconn_dns_setserver()

void espconn_dns_setserver	(	u8_t	numdns,
		ip_addr_t *	dnsserver
	)

Definition at line 1302 of file espconn.c.

Referenced by wifi_softap_ip_config().

{
    dns_setserver(numdns,dnsserver);
}

Here is the caller graph for this function:

espconn_find_connection()

bool espconn_find_connection	(	struct espconn *	pespconn,
		espconn_msg **	pnode
	)

Definition at line 186 of file espconn.c.

References ip_addr::addr, ICACHE_FLASH_ATTR, IP4_ADDR, IPADDR_ANY, NULL, _espconn_msg::pcommon, _espconn_msg::pespconn, plist, _espconn_msg::pnext, espconn::proto, _esp_tcp::remote_ip, _comon_pkt::remote_ip, _esp_tcp::remote_port, _comon_pkt::remote_port, and espconn::tcp.

Referenced by espconn_abort(), espconn_clear_opt(), espconn_delete(), espconn_disconnect(), espconn_get_keepalive(), espconn_get_packet_info(), espconn_recv_hold(), espconn_recv_unhold(), espconn_regist_time(), espconn_sendto(), espconn_sent(), espconn_set_keepalive(), and espconn_set_opt().

{
    espconn_msg *plist = NULL;
    struct ip_addr ip_remot;
    struct ip_addr ip_list;

    if (pespconn == NULL)
        return false;

    /*find the active connection node*/
    for (plist = plink_active; plist != NULL; plist = plist->pnext){
        if (pespconn == plist->pespconn) {
            *pnode = plist;
            return true;
        }
    }

    /*find the active server node*/
    for (plist = pserver_list; plist != NULL; plist = plist->pnext){
        if (pespconn == plist->pespconn) {
            if (pespconn->proto.tcp == NULL)
                return false;

            IP4_ADDR(&ip_remot, pespconn->proto.tcp->remote_ip[0],
                    pespconn->proto.tcp->remote_ip[1],
                    pespconn->proto.tcp->remote_ip[2],
                    pespconn->proto.tcp->remote_ip[3]);
            if ((ip_remot.addr == IPADDR_ANY) || (pespconn->proto.tcp->remote_port == 0))
                return false;

            /*find the active connection node*/
            for (plist = plink_active; plist != NULL; plist = plist->pnext){
                IP4_ADDR(&ip_list, plist->pcommon.remote_ip[0],
                        plist->pcommon.remote_ip[1], plist->pcommon.remote_ip[2],
                        plist->pcommon.remote_ip[3]);
                if ((ip_list.addr == ip_remot.addr) && (pespconn->proto.tcp->remote_port == plist->pcommon.remote_port)) {
                    *pnode = plist;
                    return true;
                }
            }
            return false;
        }
    }
    return false;
}

Here is the caller graph for this function:

espconn_get_connection_info()

sint8 espconn_get_connection_info	(	struct espconn *	pespconn,
		remot_info **	pcon_info,
		uint8	typeflags
	)

Definition at line 825 of file espconn.c.

Referenced by captdnsRecv(), espconn_tcp_accept(), and espconn_tcp_delete().

{
    espconn_msg *plist = NULL;

    if (pespconn == NULL)
        return ESPCONN_ARG;

    os_memset(premot, 0, sizeof(premot));
    pespconn->link_cnt = 0;
    plist = plink_active;
    switch (pespconn->type){
        case ESPCONN_TCP:
            while(plist != NULL){
                if (plist->preverse == pespconn){
                    premot[pespconn->link_cnt].state = plist->pespconn->state;
                    premot[pespconn->link_cnt].remote_port = plist->pcommon.remote_port;
                    os_memcpy(premot[pespconn->link_cnt].remote_ip, plist->pcommon.remote_ip, 4);
                    pespconn->link_cnt ++;
                }
                plist = plist->pnext;
            }

            break;
        case ESPCONN_UDP:
            while(plist != NULL){
                if (plist->pespconn == pespconn){
                    premot[pespconn->link_cnt].state = plist->pespconn->state;
                    premot[pespconn->link_cnt].remote_port = plist->pcommon.remote_port;
                    os_memcpy(premot[pespconn->link_cnt].remote_ip, plist->pcommon.remote_ip, 4);
                    pespconn->link_cnt ++;
                }
                plist = plist->pnext;
            }
            break;
        default:
            break;
    }
    *pcon_info = premot;
    if (pespconn->link_cnt == 0)
        return ESPCONN_ARG;
    return ESPCONN_OK;
}

Here is the caller graph for this function:

espconn_get_keepalive()

sint8 espconn_get_keepalive	(	struct espconn *	espconn,
		uint8	level,
		void *	optarg
	)

Definition at line 1173 of file espconn.c.

{
    espconn_msg *pnode = NULL;
    bool value = false;
    sint8 ret = ESPCONN_OK;

    if (espconn == NULL || optarg == NULL) {
        return ESPCONN_ARG;;
    } else if (espconn->type != ESPCONN_TCP)
        return ESPCONN_ARG;

    /*Find the node depend on the espconn message*/
    value = espconn_find_connection(espconn, &pnode);
    if (value && espconn_keepalive_disabled(pnode)) {
        struct tcp_pcb *pcb = pnode->pcommon.pcb;
        switch (level) {
        case ESPCONN_KEEPIDLE:
            *(int*)optarg = (int)(pcb->keep_idle/1000);
            ret = ESPCONN_OK;
            break;
        case ESPCONN_KEEPINTVL:
            *(int*)optarg = (int)(pcb->keep_intvl/1000);
            ret = ESPCONN_OK;
            break;
        case ESPCONN_KEEPCNT:
            *(int*)optarg = (int)(pcb->keep_cnt);
            ret = ESPCONN_OK;
            break;
        default:
            ret = ESPCONN_ARG;
            break;
        }
        return ret;
    } else
        return ESPCONN_ARG;
}

espconn_get_packet_info()

sint8 espconn_get_packet_info	(	struct espconn *	espconn,
		struct espconn_packet *	infoarg
	)

Definition at line 1004 of file espconn.c.

{
    espconn_msg *pnode = NULL;
    err_t err;
    bool value = false;

    if (espconn == NULL || infoarg == NULL) {
        return ESPCONN_ARG;;
    } else if (espconn->type != ESPCONN_TCP)
        return ESPCONN_ARG;

    /*Find the node depend on the espconn message*/
    value = espconn_find_connection(espconn, &pnode);
    if (value) {
        struct tcp_pcb *pcb = pnode->pcommon.pcb;
        if (pcb == NULL)
            return ESPCONN_ARG;

        pnode->pcommon.packet_info.packseq_nxt = pcb->rcv_nxt;
        pnode->pcommon.packet_info.packseqno = pcb->snd_nxt;
        pnode->pcommon.packet_info.snd_buf_size = pcb->snd_buf;
        pnode->pcommon.packet_info.total_queuelen = TCP_SND_QUEUELEN;
        pnode->pcommon.packet_info.snd_queuelen = pnode->pcommon.packet_info.total_queuelen - pcb->snd_queuelen;
        os_memcpy(infoarg,(void*)&pnode->pcommon.packet_info, sizeof(struct espconn_packet));
        return ESPCONN_OK;
    } else {
        switch (espconn->state){
            case ESPCONN_CLOSE:
                os_memcpy(infoarg,(void*)&pktinfo[0], sizeof(struct espconn_packet));
                err = ESPCONN_OK;
                break;
            case ESPCONN_NONE:
                os_memcpy(infoarg,(void*)&pktinfo[1], sizeof(struct espconn_packet));
                err = ESPCONN_OK;
                break;
            default:
                err = ESPCONN_ARG;
                break;
        }
        return err;
    }
}

espconn_gethostbyname()

sint8 espconn_gethostbyname	(	struct espconn *	pespconn,
		const char *	name,
		ip_addr_t *	addr,
		dns_found_callback	found
	)

Definition at line 1288 of file espconn.c.

Referenced by MQTT_Connect().

{
    return dns_gethostbyname(hostname, addr, found, pespconn);
}

Here is the caller graph for this function:

espconn_igmp_join()

sint8 espconn_igmp_join	(	ip_addr_t *	host_ip,
		ip_addr_t *	multicast_ip
	)

Definition at line 414 of file espconn_udp.c.

{
    if (igmp_joingroup(host_ip, multicast_ip) != ERR_OK) {
        LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("udp_join_multigrup failed!\n"));
        return -1;
    };

    /* join to any IP address at the port  */
    return ESPCONN_OK;
}

espconn_igmp_leave()

sint8 espconn_igmp_leave	(	ip_addr_t *	host_ip,
		ip_addr_t *	multicast_ip
	)

Definition at line 396 of file espconn_udp.c.

{
    if (igmp_leavegroup(host_ip, multicast_ip) != ERR_OK) {
        LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("udp_leave_multigrup failed!\n"));
        return -1;
    };

    return ESPCONN_OK;
}

espconn_list_creat()

void espconn_list_creat	(	espconn_msg **	phead,
		espconn_msg *	pinsert
	)

Definition at line 76 of file espconn.c.

References NULL, plist, and _espconn_msg::pnext.

Referenced by espconn_tcp_accept(), espconn_tcp_client(), espconn_tcp_server(), and espconn_udp_server().

{
    espconn_msg *plist = NULL;
//  espconn_msg *ptest = NULL;
    if (*phead == NULL)
        *phead = pinsert;
    else {
        plist = *phead;
        while (plist->pnext != NULL) {
            plist = plist->pnext;
        }
        plist->pnext = pinsert;
    }
    pinsert->pnext = NULL;

/*  ptest = *phead;
    while(ptest != NULL){
        os_printf("espconn_list_creat %p\n", ptest);
        ptest = ptest->pnext;
    }*/
}

Here is the caller graph for this function:

espconn_list_delete()

void espconn_list_delete	(	espconn_msg **	phead,
		espconn_msg *	pdelete
	)

Definition at line 104 of file espconn.c.

References NULL, plist, and _espconn_msg::pnext.

Referenced by espconn_Task(), espconn_tcp_client(), espconn_tcp_delete(), and espconn_udp_disconnect().

{
    espconn_msg *plist = NULL;
//  espconn_msg *ptest = NULL;
    plist = *phead;
    if (plist == NULL){
        *phead = NULL;
    } else {
        if (plist == pdelete){
            *phead = plist->pnext;
        } else {
            while (plist != NULL) {
                if (plist->pnext == pdelete){
                    plist->pnext = pdelete->pnext;
                }
                plist = plist->pnext;
            }
        }
    }
/*  ptest = *phead;
    while(ptest != NULL){
        os_printf("espconn_list_delete %p\n", ptest);
        ptest = ptest->pnext;
    }*/
}

Here is the caller graph for this function:

espconn_mdns_close()

void espconn_mdns_close

(

void

)

Definition at line 119 of file espconn_mdns.c.

{
    mdns_close();
}

espconn_mdns_disable()

void espconn_mdns_disable

(

void

)

Definition at line 37 of file espconn_mdns.c.

{
    mdns_disable();
}

espconn_mdns_enable()

void espconn_mdns_enable

(

void

)

Definition at line 25 of file espconn_mdns.c.

{
    mdns_enable();
}

espconn_mdns_get_hostname()

char* espconn_mdns_get_hostname

(

void

)

Definition at line 63 of file espconn_mdns.c.

{
    return (char *)mdns_get_hostname();
}

espconn_mdns_get_servername()

char* espconn_mdns_get_servername

(

void

)

Definition at line 85 of file espconn_mdns.c.

{
    return (char *)mdns_get_servername();
}

espconn_mdns_init()

void espconn_mdns_init

(

struct mdns_info *

info

)

Definition at line 131 of file espconn_mdns.c.

{
    mdns_init(info);
}

espconn_mdns_server_register()

void espconn_mdns_server_register

(

void

)

Definition at line 96 of file espconn_mdns.c.

{
    mdns_server_register();
}

espconn_mdns_server_unregister()

void espconn_mdns_server_unregister

(

void

)

Definition at line 107 of file espconn_mdns.c.

{
    mdns_server_unregister();
}

espconn_mdns_set_hostname()

void espconn_mdns_set_hostname

(

char *

name

)

Definition at line 50 of file espconn_mdns.c.

{
    mdns_set_hostname(name);
}

espconn_mdns_set_servername()

void espconn_mdns_set_servername

(

const char *

name

)

Definition at line 74 of file espconn_mdns.c.

{
    mdns_set_servername(name);
}

espconn_port()

uint32 espconn_port

(

void

)

Definition at line 1245 of file espconn.c.

Referenced by MQTT_Connect().

{
    uint32 port = 0;
    static uint32 randnum = 0;

    do {
        port = os_random();

        if (port < 0) {
            port = os_random() - port;
        }

        port %= 0xc350;

        if (port < 0x400) {
            port += 0x400;
        }

    } while (port == randnum);

    randnum = port;

    return port;
}

Here is the caller graph for this function:

espconn_regist_connectcb()

sint8 espconn_regist_connectcb	(	struct espconn *	espconn,
		espconn_connect_callback	connect_cb
	)

Definition at line 751 of file espconn.c.

Referenced by httpdInit(), and MQTT_Connect().

{
    if (espconn == NULL) {
        return ESPCONN_ARG;
    }

    espconn->proto.tcp->connect_callback = connect_cb;
    return ESPCONN_OK;
}

Here is the caller graph for this function:

espconn_regist_disconcb()

sint8 espconn_regist_disconcb	(	struct espconn *	espconn,
		espconn_connect_callback	discon_cb
	)

Definition at line 807 of file espconn.c.

Referenced by httpdConnectCb(), and mqtt_tcpclient_connect_cb().

{
    if (espconn == NULL) {
        return ESPCONN_ARG;
    }

    espconn ->proto.tcp->disconnect_callback = discon_cb;
    return ESPCONN_OK;
}

Here is the caller graph for this function:

espconn_regist_reconcb()

sint8 espconn_regist_reconcb	(	struct espconn *	espconn,
		espconn_reconnect_callback	recon_cb
	)

Definition at line 789 of file espconn.c.

Referenced by httpdConnectCb(), and MQTT_Connect().

{
    if (espconn == NULL) {
        return ESPCONN_ARG;
    }

    espconn ->proto.tcp->reconnect_callback = recon_cb;
    return ESPCONN_OK;
}

Here is the caller graph for this function:

espconn_regist_recvcb()

sint8 espconn_regist_recvcb	(	struct espconn *	espconn,
		espconn_recv_callback	recv_cb
	)

Definition at line 770 of file espconn.c.

Referenced by captdnsInit(), httpdConnectCb(), and mqtt_tcpclient_connect_cb().

{
    if (espconn == NULL) {
        return ESPCONN_ARG;
    }

    espconn ->recv_callback = recv_cb;
    return ESPCONN_OK;
}

Here is the caller graph for this function:

espconn_regist_sentcb()

sint8 espconn_regist_sentcb	(	struct espconn *	espconn,
		espconn_sent_callback	sent_cb
	)

Definition at line 712 of file espconn.c.

Referenced by httpdConnectCb(), and mqtt_tcpclient_connect_cb().

{
    if (espconn == NULL) {
        return ESPCONN_ARG;
    }

    espconn ->sent_callback = sent_cb;
    return ESPCONN_OK;
}

Here is the caller graph for this function:

espconn_regist_time()

sint8 espconn_regist_time	(	struct espconn *	espconn,
		uint32	interval,
		uint8	type_flag
	)

Definition at line 905 of file espconn.c.

{
    espconn_msg *pnode = NULL;
    espconn_msg *ptime_msg = NULL;
    bool value = false;
    if ((espconn == NULL) || (type_flag > 0x01))
        return ESPCONN_ARG;

    if (type_flag == 0x01){
        /*set the timeout time for one active connection of the server*/
        value = espconn_find_connection(espconn, &pnode);
        if (value){
            pnode->pcommon.timeout = interval;
            return ESPCONN_OK;
        } else
            return ESPCONN_ARG;
    } else {
        /*set the timeout time for all active connection of the server*/
        ptime_msg = pserver_list;
        while (ptime_msg != NULL){
            if (ptime_msg->pespconn == espconn){
                ptime_msg->pcommon.timeout = interval;
                return ESPCONN_OK;
            }
            ptime_msg = ptime_msg->pnext;
        }
    }
    return ESPCONN_ARG;
}

espconn_regist_write_finish()

sint8 espconn_regist_write_finish	(	struct espconn *	espconn,
		espconn_connect_callback	write_finish_fn
	)

Definition at line 732 of file espconn.c.

{
    if (espconn == NULL || espconn ->proto.tcp == NULL || espconn->type == ESPCONN_UDP) {
        return ESPCONN_ARG;
    }

    espconn ->proto.tcp->write_finish_fn = write_finish_fn;
    return ESPCONN_OK;
}

espconn_sent()

sint8 espconn_sent	(	struct espconn *	espconn,
		uint8 *	psent,
		uint16	length
	)

Definition at line 368 of file espconn.c.

Referenced by cgiEspFsHook(), and xmitSendBuff().

{
    espconn_msg *pnode = NULL;
    bool value = false;
    err_t error = ESPCONN_OK;
    
    if (espconn == NULL || psent == NULL || length == 0) {
        return ESPCONN_ARG;
    }

    /*Find the node depend on the espconn message*/
    value = espconn_find_connection(espconn, &pnode);

    if (value){
        espconn ->state = ESPCONN_WRITE;
        switch (espconn ->type) {
            case ESPCONN_TCP:
                /* calling sent function frequently,make sure last packet has been backup or sent fully*/
                if (pnode->pcommon.write_flag){
                    espconn_buf *pbuf = NULL;
                    /*If total number of espconn_buf on the unsent lists exceeds the set maximum, return an error */
                    if (espconn_copy_enabled(pnode)){
                        if (espconn_tcp_get_buf_count(pnode->pcommon.pbuf) >= pnode ->pcommon.pbuf_num)
                            return ESPCONN_MAXNUM;
                    } else {
                        struct tcp_pcb *pcb = pnode->pcommon.pcb;
                        if (pcb->snd_queuelen >= TCP_SND_QUEUELEN)
                            return ESPCONN_MAXNUM;
                    }

                    pbuf = (espconn_buf*) os_zalloc(sizeof(espconn_buf));
                    if (pbuf == NULL)
                        return ESPCONN_MEM;
                    else {
                        /*Backup the application packet information for send more data*/
                        pbuf->payload = psent;
                        pbuf->punsent = pbuf->payload;
                        pbuf->unsent = length;
                        pbuf->len = length;
                        /*insert the espconn_pbuf to the list*/
                        espconn_pbuf_create(&pnode->pcommon.pbuf, pbuf);
                        if (pnode->pcommon.ptail == NULL)
                            pnode->pcommon.ptail = pbuf;
                    }
                    /*when set the data copy option. change the flag for next packet*/
                    if (espconn_copy_disabled(pnode))
                        pnode->pcommon.write_flag = false;
                    error = espconn_tcp_write(pnode);
//                  if (error != ESPCONN_OK){
//                      /*send the application packet fail,
//                       * ensure that each allocated is deleted*/
//                      espconn_pbuf_delete(&pnode->pcommon.pbuf, pbuf);
//                      os_free(pbuf);
//                      pbuf = NULL;
//                  }
                    return error;
                } else
                    return ESPCONN_ARG;
                break;

            case ESPCONN_UDP:
                return espconn_udp_sent(pnode, psent, length);
                break;

            default :
                break;
        }
    }
    return ESPCONN_ARG;
}

Here is the caller graph for this function:

espconn_set_keepalive()

sint8 espconn_set_keepalive	(	struct espconn *	espconn,
		uint8	level,
		void *	optarg
	)

Definition at line 1128 of file espconn.c.

Referenced by MQTT_Connect().

{
    espconn_msg *pnode = NULL;
    bool value = false;
    sint8 ret = ESPCONN_OK;

    if (espconn == NULL || optarg == NULL) {
        return ESPCONN_ARG;;
    } else if (espconn->type != ESPCONN_TCP)
        return ESPCONN_ARG;

    /*Find the node depend on the espconn message*/
    value = espconn_find_connection(espconn, &pnode);
    if (value && espconn_keepalive_disabled(pnode)) {
        struct tcp_pcb *pcb = pnode->pcommon.pcb;
        switch (level){
            case ESPCONN_KEEPIDLE:
                pcb->keep_idle = 1000 * (u32_t)(*(int*)optarg);
                ret = ESPCONN_OK;
                break;
            case ESPCONN_KEEPINTVL:
                pcb->keep_intvl = 1000 * (u32_t)(*(int*)optarg);
                ret = ESPCONN_OK;
                break;
            case ESPCONN_KEEPCNT:
                pcb->keep_cnt = (u32_t)(*(int*)optarg);
                ret = ESPCONN_OK;
                break;
            default:
                ret = ESPCONN_ARG;
                break;
        }
        return ret;
    } else
        return ESPCONN_ARG;
}

Here is the caller graph for this function:

espconn_set_opt()

sint8 espconn_set_opt	(	struct espconn *	espconn,
		uint8	opt
	)

Definition at line 1056 of file espconn.c.

Referenced by MQTT_Connect().

{
    espconn_msg *pnode = NULL;
    struct tcp_pcb *tpcb;
    bool value = false;

    if (espconn == NULL) {
        return ESPCONN_ARG;;
    } else if (espconn->type != ESPCONN_TCP)
        return ESPCONN_ARG;

    /*Find the node depend on the espconn message*/
    value = espconn_find_connection(espconn, &pnode);
    if (value) {
        pnode->pcommon.espconn_opt |= opt;
        tpcb = pnode->pcommon.pcb;
        if (espconn_delay_disabled(pnode))
            tcp_nagle_disable(tpcb);

        if (espconn_keepalive_disabled(pnode))
            espconn_keepalive_enable(tpcb);

        return ESPCONN_OK;
    } else
        return ESPCONN_ARG;
}

Here is the caller graph for this function:

espconn_tcp_get_max_con()

uint8 espconn_tcp_get_max_con

(

void

)

Definition at line 528 of file espconn.c.

{
    uint8 tcp_num = 0;

    tcp_num = MEMP_NUM_TCP_PCB;

    return tcp_num;
}

espconn_tcp_get_max_con_allow()

sint8 espconn_tcp_get_max_con_allow

(

struct espconn *

espconn

)

Definition at line 618 of file espconn.c.

Referenced by espconn_tcp_accept().

{
    espconn_msg *pget_msg = NULL;
    if ((espconn == NULL) || (espconn->type == ESPCONN_UDP))
        return ESPCONN_ARG;

    pget_msg = pserver_list;
    while (pget_msg != NULL){
        if (pget_msg->pespconn == espconn){
            return pget_msg->count_opt;
        }
        pget_msg = pget_msg->pnext;
    }
    return ESPCONN_ARG;
}

Here is the caller graph for this function:

espconn_tcp_get_max_retran()

uint8 espconn_tcp_get_max_retran

(

void

)

Definition at line 558 of file espconn.c.

References TCP_MAXRTX.

{
    uint8 tcp_num = 0;

    tcp_num = TCP_MAXRTX;

    return tcp_num;
}

espconn_tcp_get_max_syn()

uint8 espconn_tcp_get_max_syn

(

void

)

Definition at line 588 of file espconn.c.

References TCP_SYNMAXRTX.

{
    uint8 tcp_num = 0;

    tcp_num = TCP_SYNMAXRTX;

    return tcp_num;
}

espconn_tcp_get_wnd()

uint8 espconn_tcp_get_wnd

(

void

)

Definition at line 483 of file espconn.c.

References TCP_MSS, and TCP_WND.

{
    uint8 tcp_num = 0;

    tcp_num = (TCP_WND / TCP_MSS);

    return tcp_num;
}

espconn_tcp_set_buf_count()

sint8 espconn_tcp_set_buf_count	(	struct espconn *	espconn,
		uint8	num
	)

Definition at line 665 of file espconn.c.

References ESPCONN_ARG, ESPCONN_OK, ESPCONN_TCP, NULL, _comon_pkt::pbuf_num, _espconn_msg::pcommon, _espconn_msg::pespconn, plist, _espconn_msg::pnext, TCP_SND_QUEUELEN, and espconn::type.

Referenced by espconn_client_connect(), and espconn_tcp_accept().

{
    espconn_msg *plist = NULL;
    if (espconn == NULL || (num > TCP_SND_QUEUELEN))
        return ESPCONN_ARG;

    /*find the node from the active connection list*/
    for (plist = plink_active; plist != NULL; plist = plist->pnext){
        if (plist->pespconn && plist->pespconn == espconn && espconn->type == ESPCONN_TCP){
            plist->pcommon.pbuf_num = num;
            return ESPCONN_OK;
        }
    }

    if (plist == NULL)
        return ESPCONN_ARG;
}

Here is the caller graph for this function:

espconn_tcp_set_max_con()

sint8 espconn_tcp_set_max_con

(

uint8

num

)

Definition at line 543 of file espconn.c.

{
    if (num == 0 || num > linkMax)
        return ESPCONN_ARG;

    MEMP_NUM_TCP_PCB = num;
    return ESPCONN_OK;
}

espconn_tcp_set_max_con_allow()

sint8 espconn_tcp_set_max_con_allow	(	struct espconn *	espconn,
		uint8	num
	)

Definition at line 640 of file espconn.c.

{
    espconn_msg *pset_msg = NULL;
    if ((espconn == NULL) || (num > MEMP_NUM_TCP_PCB) || (espconn->type == ESPCONN_UDP))
        return ESPCONN_ARG;

    pset_msg = pserver_list;
    while (pset_msg != NULL){
        if (pset_msg->pespconn == espconn){
            pset_msg->count_opt = num;
            return ESPCONN_OK;
        }
        pset_msg = pset_msg->pnext;
    }
    return ESPCONN_ARG;
}

espconn_tcp_set_max_retran()

sint8 espconn_tcp_set_max_retran

(

uint8

num

)

Definition at line 573 of file espconn.c.

References ESPCONN_ARG, ESPCONN_OK, and TCP_MAXRTX.

{
    if (num == 0 || num > 12)
        return ESPCONN_ARG;

    TCP_MAXRTX = num;
    return ESPCONN_OK;
}

espconn_tcp_set_max_syn()

sint8 espconn_tcp_set_max_syn

(

uint8

num

)

Definition at line 603 of file espconn.c.

References ESPCONN_ARG, ESPCONN_OK, and TCP_SYNMAXRTX.

{
    if (num == 0 || num > 12)
        return ESPCONN_ARG;

    TCP_SYNMAXRTX = num;
    return ESPCONN_OK;
}

espconn_tcp_set_wnd()

sint8 espconn_tcp_set_wnd

(

uint8

num

)

Definition at line 498 of file espconn.c.

References ESPCONN_ARG, ESPCONN_OK, linkMax, TCP_MSS, and TCP_WND.

{
    if (num == 0 || num > linkMax)
        return ESPCONN_ARG;

    TCP_WND = (num * TCP_MSS);
    return ESPCONN_OK;
}