espconn_udp.c File Reference

#include "ets_sys.h"
#include "os_type.h"
#include "lwip/inet.h"
#include "lwip/err.h"
#include "lwip/pbuf.h"
#include "lwip/mem.h"
#include "lwip/tcp_impl.h"
#include "lwip/udp.h"
#include "lwip/app/espconn_udp.h"

Include dependency graph for espconn_udp.c:

Go to the source code of this file.

Enumerations
enum	send_opt { ESPCONN_SENDTO, ESPCONN_SEND }

Functions
static void ICACHE_FLASH_ATTR	espconn_data_sentcb (struct espconn *pespconn)
static void ICACHE_FLASH_ATTR	espconn_data_sent (void *arg, enum send_opt opt)
err_t ICACHE_FLASH_ATTR	espconn_udp_sent (void *arg, uint8 *psent, uint16 length)
err_t ICACHE_FLASH_ATTR	espconn_udp_sendto (void *arg, uint8 *psent, uint16 length)
static void ICACHE_FLASH_ATTR	espconn_udp_recv (void *arg, struct udp_pcb *upcb, struct pbuf *p, struct ip_addr *addr, u16_t port)
void ICACHE_FLASH_ATTR	espconn_udp_disconnect (espconn_msg *pdiscon)
sint8 ICACHE_FLASH_ATTR	espconn_udp_server (struct espconn *pespconn)
sint8 ICACHE_FLASH_ATTR	espconn_igmp_leave (ip_addr_t *host_ip, ip_addr_t *multicast_ip)
sint8 ICACHE_FLASH_ATTR	espconn_igmp_join (ip_addr_t *host_ip, ip_addr_t *multicast_ip)

Variables
espconn_msg *	plink_active
uint8	default_interface

Enumeration Type Documentation

send_opt

enum send_opt

Enumerator
ESPCONN_SENDTO
ESPCONN_SEND

Definition at line 32 of file espconn_udp.c.

             {
    ESPCONN_SENDTO,
    ESPCONN_SEND
};

Function Documentation

espconn_data_sent()

static void ICACHE_FLASH_ATTR espconn_data_sent ( void *  arg, enum send_opt  opt  )

static

Definition at line 47 of file espconn_udp.c.

References _comon_pkt::cntr, ESPCONN_CONNECT, espconn_data_sentcb(), ESPCONN_SEND, espconn_udp_sendto(), espconn_udp_sent(), ICACHE_FLASH_ATTR, NULL, _espconn_msg::pcommon, _espconn_msg::pespconn, _comon_pkt::ptrbuf, and espconn::state.

Referenced by espconn_udp_sendto(), and espconn_udp_sent().

{
    espconn_msg *psent = arg;

    if (psent == NULL) {
        return;
    }

    if (psent->pcommon.cntr == 0) {
        psent->pespconn->state = ESPCONN_CONNECT;
//        sys_timeout(10, espconn_data_sentcb, psent->pespconn);
        espconn_data_sentcb(psent->pespconn);
    } else {
        if (opt == ESPCONN_SEND){
            espconn_udp_sent(arg, psent->pcommon.ptrbuf, psent->pcommon.cntr);
        } else {
            espconn_udp_sendto(arg, psent->pcommon.ptrbuf, psent->pcommon.cntr);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

espconn_data_sentcb()

static void ICACHE_FLASH_ATTR espconn_data_sentcb ( struct espconn *  pespconn )

static

Definition at line 36 of file espconn_udp.c.

References NULL, and espconn::sent_callback.

Referenced by espconn_data_sent().

{
    if (pespconn == NULL) {
        return;
    }

    if (pespconn->sent_callback != NULL) {
        pespconn->sent_callback(pespconn);
    }
}

Here is the caller graph for this function:

espconn_igmp_join()

sint8 ICACHE_FLASH_ATTR espconn_igmp_join	(	ip_addr_t *	host_ip,
		ip_addr_t *	multicast_ip
	)

Definition at line 414 of file espconn_udp.c.

References ERR_OK, ESPCONN_OK, ESPCONN_UDP_DEBUG, and LWIP_DEBUGF.

{
    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 ICACHE_FLASH_ATTR espconn_igmp_leave	(	ip_addr_t *	host_ip,
		ip_addr_t *	multicast_ip
	)

Definition at line 396 of file espconn_udp.c.

References ERR_OK, ESPCONN_OK, ESPCONN_UDP_DEBUG, ICACHE_FLASH_ATTR, and LWIP_DEBUGF.

{
    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_udp_disconnect()

void ICACHE_FLASH_ATTR espconn_udp_disconnect

(

espconn_msg *

pdiscon

)

Definition at line 338 of file espconn_udp.c.

References espconn_list_delete(), ICACHE_FLASH_ATTR, NULL, os_free, _comon_pkt::pcb, and _espconn_msg::pcommon.

Referenced by espconn_delete().

{
    if (pdiscon == NULL) {
        return;
    }

    struct udp_pcb *upcb = pdiscon->pcommon.pcb;

    udp_disconnect(upcb);

    udp_remove(upcb);

    espconn_list_delete(&plink_active, pdiscon);

    os_free(pdiscon);
    pdiscon = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

espconn_udp_recv()

static void ICACHE_FLASH_ATTR espconn_udp_recv ( void *  arg, struct udp_pcb *  upcb, struct pbuf *  p, struct ip_addr *  addr, u16_t  port  )

static

Definition at line 283 of file espconn_udp.c.

References ESPCONN_UDP_DEBUG, ip_info::ip, ip4_addr1_16, ip4_addr2_16, ip4_addr3_16, ip4_addr4_16, ip_addr_netcmp, _esp_udp::local_ip, LWIP_DEBUGF, ip_info::netmask, NULL, os_free, os_zalloc, pbuf_copy_partial(), pbuf_free(), _comon_pkt::pcb, _espconn_msg::pcommon, _espconn_msg::pespconn, espconn::proto, espconn::recv_callback, _comon_pkt::remote_ip, _comon_pkt::remote_port, espconn::udp, wifi_get_ip_info(), and wifi_get_opmode().

Referenced by espconn_udp_server().

{
    espconn_msg *precv = arg;
    struct pbuf *q = NULL;
    u8_t *pdata = NULL;
    u16_t length = 0;
    struct ip_info ipconfig;

    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_server_recv %d %p\n", __LINE__, upcb));

    precv->pcommon.remote_ip[0] = ip4_addr1_16(addr);
    precv->pcommon.remote_ip[1] = ip4_addr2_16(addr);
    precv->pcommon.remote_ip[2] = ip4_addr3_16(addr);
    precv->pcommon.remote_ip[3] = ip4_addr4_16(addr);
    precv->pcommon.remote_port = port;
    precv->pcommon.pcb = upcb;

    if (wifi_get_opmode() != 1) {
        wifi_get_ip_info(1, &ipconfig);

        if (!ip_addr_netcmp(addr, &ipconfig.ip, &ipconfig.netmask)) {
            wifi_get_ip_info(0, &ipconfig);
        }
    } else {
        wifi_get_ip_info(0, &ipconfig);
    }

    precv->pespconn->proto.udp->local_ip[0] = ip4_addr1_16(&ipconfig.ip);
    precv->pespconn->proto.udp->local_ip[1] = ip4_addr2_16(&ipconfig.ip);
    precv->pespconn->proto.udp->local_ip[2] = ip4_addr3_16(&ipconfig.ip);
    precv->pespconn->proto.udp->local_ip[3] = ip4_addr4_16(&ipconfig.ip);

    if (p != NULL) {
        pdata = (u8_t *)os_zalloc(p ->tot_len + 1);
        length = pbuf_copy_partial(p, pdata, p ->tot_len, 0);
        precv->pcommon.pcb = upcb;
        pbuf_free(p);
        if (length != 0) {
            if (precv->pespconn->recv_callback != NULL) {
                precv->pespconn->recv_callback(precv->pespconn, pdata, length);
            }
        }
        os_free(pdata);
    } else {
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

espconn_udp_sendto()

err_t ICACHE_FLASH_ATTR espconn_udp_sendto	(	void *	arg,
		uint8 *	psent,
		uint16	length
	)

Definition at line 183 of file espconn_udp.c.

References _comon_pkt::cntr, default_interface, eagle_lwip_getif(), ERR_OK, ESPCONN_AP_STA, ESPCONN_ARG, espconn_data_sent(), ESPCONN_IF, ESPCONN_MEM, ESPCONN_RTE, ESPCONN_SENDTO, ESPCONN_UDP_DEBUG, ICACHE_FLASH_ATTR, IP4_ADDR, pbuf::len, LWIP_DEBUGF, netif_is_up, netif_set_default(), pbuf::next, NULL, pbuf::payload, pbuf_alloc(), pbuf_copy(), pbuf_free(), PBUF_RAM, PBUF_TRANSPORT, _comon_pkt::pcb, _espconn_msg::pcommon, _espconn_msg::pespconn, espconn::proto, _comon_pkt::ptrbuf, pbuf::ref, _esp_udp::remote_ip, _esp_udp::remote_port, espconn::udp, and wifi_get_opmode().

Referenced by espconn_data_sent(), and espconn_sendto().

{
    espconn_msg *pudp_sent = arg;
    struct udp_pcb *upcb = pudp_sent->pcommon.pcb;
    struct espconn *pespconn = pudp_sent->pespconn;
    struct pbuf *p, *q ,*p_temp;
    struct ip_addr dst_ip;
    u16_t dst_port;
    u8_t *data = NULL;
    u16_t cnt = 0;
    u16_t datalen = 0;
    u16_t i = 0;
    err_t err;
    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %d %p\n", __LINE__, length, upcb));

    if (pudp_sent == NULL || upcb == NULL || psent == NULL || length == 0) {
        return ESPCONN_ARG;
    }

    if (1470 < length) {
        datalen = 1470;
    } else {
        datalen = length;
    }

    p = pbuf_alloc(PBUF_TRANSPORT, datalen, PBUF_RAM);
    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %p\n", __LINE__, p));

    if (p != NULL) {
        q = p;

        while (q != NULL) {
            data = (u8_t *)q->payload;
            LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %p\n", __LINE__, data));

            for (i = 0; i < q->len; i++) {
                data[i] = ((u8_t *) psent)[cnt++];
            }

            q = q->next;
        }
    } else {
        return ESPCONN_MEM;
    }

    dst_port = pespconn->proto.udp->remote_port;
    IP4_ADDR(&dst_ip, pespconn->proto.udp->remote_ip[0],
            pespconn->proto.udp->remote_ip[1], pespconn->proto.udp->remote_ip[2],
            pespconn->proto.udp->remote_ip[3]);
    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %x %d\n", __LINE__, upcb->remote_ip, upcb->remote_port));

    struct netif *sta_netif = (struct netif *)eagle_lwip_getif(0x00);
    struct netif *ap_netif =  (struct netif *)eagle_lwip_getif(0x01);

    if(wifi_get_opmode() == ESPCONN_AP_STA && default_interface == ESPCONN_AP_STA && sta_netif != NULL && ap_netif != NULL)
    {
        if(netif_is_up(sta_netif) && netif_is_up(ap_netif) && \
            ip_addr_isbroadcast(&upcb->remote_ip, sta_netif) && \
            ip_addr_isbroadcast(&upcb->remote_ip, ap_netif)) {

          p_temp = pbuf_alloc(PBUF_TRANSPORT, datalen, PBUF_RAM);
          if (pbuf_copy (p_temp,p) != ERR_OK) {
              LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sendto: copying to new pbuf failed\n"));
              return ESPCONN_ARG;
          }
          netif_set_default(sta_netif);
          err = udp_sendto(upcb, p_temp, &dst_ip, dst_port);
          pbuf_free(p_temp);
          netif_set_default(ap_netif);
        }
    }
    err = udp_sendto(upcb, p, &dst_ip, dst_port);

    if (p->ref != 0) {
        pbuf_free(p);
        pudp_sent->pcommon.ptrbuf = psent + datalen;
        pudp_sent->pcommon.cntr = length - datalen;
        if (err == ERR_OK)
            espconn_data_sent(pudp_sent, ESPCONN_SENDTO);

        if (err > 0)
            return ESPCONN_IF;
        return err;
    } else {
        pbuf_free(p);
        return ESPCONN_RTE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

espconn_udp_sent()

err_t ICACHE_FLASH_ATTR espconn_udp_sent	(	void *	arg,
		uint8 *	psent,
		uint16	length
	)

Definition at line 81 of file espconn_udp.c.

References _comon_pkt::cntr, default_interface, eagle_lwip_getif(), ERR_OK, ESPCONN_AP_STA, ESPCONN_ARG, espconn_data_sent(), ESPCONN_IF, ESPCONN_MEM, ESPCONN_RTE, ESPCONN_SEND, ESPCONN_UDP_DEBUG, ICACHE_FLASH_ATTR, IP4_ADDR, pbuf::len, LWIP_DEBUGF, netif_is_up, netif_set_default(), pbuf::next, NULL, pbuf::payload, pbuf_alloc(), pbuf_copy(), pbuf_free(), PBUF_RAM, PBUF_TRANSPORT, _comon_pkt::pcb, _espconn_msg::pcommon, _espconn_msg::pespconn, espconn::proto, _comon_pkt::ptrbuf, pbuf::ref, _esp_udp::remote_ip, _esp_udp::remote_port, espconn::udp, and wifi_get_opmode().

Referenced by espconn_data_sent(), and espconn_sent().

{
    espconn_msg *pudp_sent = arg;
    struct udp_pcb *upcb = pudp_sent->pcommon.pcb;
    struct pbuf *p, *q ,*p_temp;
    u8_t *data = NULL;
    u16_t cnt = 0;
    u16_t datalen = 0;
    u16_t i = 0;
    err_t err;
    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %d %p\n", __LINE__, length, upcb));

    if (pudp_sent == NULL || upcb == NULL || psent == NULL || length == 0) {
        return ESPCONN_ARG;
    }

    if (1470 < length) {
        datalen = 1470;
    } else {
        datalen = length;
    }

    p = pbuf_alloc(PBUF_TRANSPORT, datalen, PBUF_RAM);
    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %p\n", __LINE__, p));

    if (p != NULL) {
        q = p;

        while (q != NULL) {
            data = (u8_t *)q->payload;
            LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %p\n", __LINE__, data));

            for (i = 0; i < q->len; i++) {
                data[i] = ((u8_t *) psent)[cnt++];
            }

            q = q->next;
        }
    } else {
        return ESPCONN_MEM;
    }

    upcb->remote_port = pudp_sent->pespconn->proto.udp->remote_port;
    IP4_ADDR(&upcb->remote_ip, pudp_sent->pespconn->proto.udp->remote_ip[0],
            pudp_sent->pespconn->proto.udp->remote_ip[1],
            pudp_sent->pespconn->proto.udp->remote_ip[2],
            pudp_sent->pespconn->proto.udp->remote_ip[3]);

    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %x %d\n", __LINE__, upcb->remote_ip, upcb->remote_port));

    struct netif *sta_netif = (struct netif *)eagle_lwip_getif(0x00);
    struct netif *ap_netif =  (struct netif *)eagle_lwip_getif(0x01);
        
    if(wifi_get_opmode() == ESPCONN_AP_STA && default_interface == ESPCONN_AP_STA && sta_netif != NULL && ap_netif != NULL)
    {
        if(netif_is_up(sta_netif) && netif_is_up(ap_netif) && \
            ip_addr_isbroadcast(&upcb->remote_ip, sta_netif) && \
            ip_addr_isbroadcast(&upcb->remote_ip, ap_netif)) {

          p_temp = pbuf_alloc(PBUF_TRANSPORT, datalen, PBUF_RAM);
          if (pbuf_copy (p_temp,p) != ERR_OK) {
              LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent: copying to new pbuf failed\n"));
              return ESPCONN_ARG;
          }
          netif_set_default(sta_netif);
          err = udp_send(upcb, p_temp);
          pbuf_free(p_temp);
          netif_set_default(ap_netif);
        }
    }
          err = udp_send(upcb, p);

    LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %d\n", __LINE__, err));

    if (p->ref != 0) {
        LWIP_DEBUGF(ESPCONN_UDP_DEBUG, ("espconn_udp_sent %d %p\n", __LINE__, p));
        pbuf_free(p);
        pudp_sent->pcommon.ptrbuf = psent + datalen;
        pudp_sent->pcommon.cntr = length - datalen;
        espconn_data_sent(pudp_sent, ESPCONN_SEND);
        if (err > 0)
            return ESPCONN_IF;
        return err;
    } else {
        pbuf_free(p);
        return ESPCONN_RTE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

espconn_udp_server()

sint8 ICACHE_FLASH_ATTR espconn_udp_server

(

struct espconn *

pespconn

)

Definition at line 363 of file espconn_udp.c.

References espconn_list_creat(), ESPCONN_MEM, ESPCONN_OK, espconn_udp_recv(), ICACHE_FLASH_ATTR, IP_ADDR_ANY, _esp_udp::local_port, NULL, os_zalloc, _comon_pkt::pcb, _espconn_msg::pcommon, _espconn_msg::pespconn, espconn::proto, and espconn::udp.

Referenced by espconn_create().

{
    struct udp_pcb *upcb = NULL;
    espconn_msg *pserver = NULL;
    upcb = udp_new();

    if (upcb == NULL) {
        return ESPCONN_MEM;
    } else {
        pserver = (espconn_msg *)os_zalloc(sizeof(espconn_msg));

        if (pserver == NULL) {
            udp_remove(upcb);
            return ESPCONN_MEM;
        }

        pserver->pcommon.pcb = upcb;
        pserver->pespconn = pespconn;
        espconn_list_creat(&plink_active, pserver);
        udp_bind(upcb, IP_ADDR_ANY, pserver->pespconn->proto.udp->local_port);
        udp_recv(upcb, espconn_udp_recv, (void *)pserver);
        return ESPCONN_OK;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

default_interface

uint8 default_interface

Referenced by espconn_udp_sendto(), and espconn_udp_sent().

plink_active

espconn_msg* plink_active

Definition at line 32 of file espconn.c.

Referenced by espconn_get_connection_info().