espconn.h

/*
 * ESPRSSIF MIT License
 *
 * Copyright (c) 2015 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
 *
 * Permission is hereby granted for use on ESPRESSIF SYSTEMS ESP8266 only, in which case,
 * it is free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the Software is furnished
 * to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

#ifndef __ESPCONN_H__
#define __ESPCONN_H__

#ifdef __cplusplus
extern "C" {
#endif

typedef sint8 err_t;

typedef void *espconn_handle;

typedef void (* espconn_connect_callback)(void *arg);

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

/* Definitions for error constants. */

#define ESPCONN_OK           0  
#define ESPCONN_MEM         -1  
#define ESPCONN_TIMEOUT     -3  
#define ESPCONN_RTE         -4  
#define ESPCONN_INPROGRESS  -5  
#define ESPCONN_MAXNUM      -7  
#define ESPCONN_ABRT        -8  
#define ESPCONN_RST         -9  
#define ESPCONN_CLSD       -10  
#define ESPCONN_CONN       -11  
#define ESPCONN_ARG        -12  
#define ESPCONN_IF         -14  
#define ESPCONN_ISCONN     -15  
enum espconn_type {
    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        
};

typedef struct _esp_tcp {
    int remote_port;      
    int local_port;       
    uint8 local_ip[4];    
    uint8 remote_ip[4];   
    espconn_connect_callback connect_callback;      
    espconn_reconnect_callback reconnect_callback;  
    espconn_connect_callback disconnect_callback;   
    espconn_connect_callback write_finish_fn;       
} esp_tcp;

typedef struct _esp_udp {
    int remote_port;    
    int local_port;     
    uint8 local_ip[4];  
    uint8 remote_ip[4]; 
} esp_udp;

typedef struct _remot_info {
    enum espconn_state state;   
    int remote_port;            
    uint8 remote_ip[4];         
} remot_info;

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

struct espconn {
    enum espconn_type type;     
    enum espconn_state state;   
    union {
        esp_tcp *tcp;
        esp_udp *udp;
    } proto;
    espconn_recv_callback recv_callback;    
    espconn_sent_callback sent_callback;    
    uint8 link_cnt;         
    void *reserve;          
};

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

enum {
    ESPCONN_IDLE = 0,
    ESPCONN_CLIENT,
    ESPCONN_SERVER,
    ESPCONN_BOTH,
    ESPCONN_MAX
};

void espconn_init(void);

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_max_con(void);

sint8 espconn_tcp_set_max_con(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_regist_time(struct espconn *espconn, uint32 interval, uint8 type_flag);

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

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_send(struct espconn *espconn, uint8 *psent, uint16 length);

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

sint16 espconn_sendto(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_clear_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);

typedef void (*dns_found_callback)(const char *name, ip_addr_t *ipaddr, void *callback_arg);

err_t espconn_gethostbyname(struct espconn *pespconn, const char *hostname, 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);

sint8 espconn_recv_hold(struct espconn *pespconn);

sint8 espconn_recv_unhold(struct espconn *pespconn);

void espconn_dns_setserver(char numdns, ip_addr_t *dnsserver);

#ifdef __cplusplus
}
#endif

#endif