espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-30 18:57:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

components: Use CONFIG_LWIP_IPV6 to strip IPv6 function in components

Browse Source 
* Original commit: espressif/esp-idf@da58235a0e
This commit is contained in:
yuanjm
2021-01-18 19:14:51 +08:00
committed by suren-gabrielyan-espressif
parent b114ed69de
commit 1623c0e729
4 changed files with 62 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/mdns/include/mdns.h
View File

@ -339,6 +339,7 @@ esp_err_t mdns_query_txt(const char * instance_name, const char * service_type,
*/ */
esp_err_t mdns_query_a(const char * host_name, uint32_t timeout, esp_ip4_addr_t * addr); esp_err_t mdns_query_a(const char * host_name, uint32_t timeout, esp_ip4_addr_t * addr);
#if CONFIG_LWIP_IPV6
/** /**
* @brief Query mDNS for A record * @brief Query mDNS for A record
* *
@ -353,6 +354,7 @@ esp_err_t mdns_query_a(const char * host_name, uint32_t timeout, esp_ip4_addr_t
* - ESP_ERR_INVALID_ARG parameter error * - ESP_ERR_INVALID_ARG parameter error
*/ */
esp_err_t mdns_query_aaaa(const char * host_name, uint32_t timeout, esp_ip6_addr_t * addr); esp_err_t mdns_query_aaaa(const char * host_name, uint32_t timeout, esp_ip6_addr_t * addr);
#endif
/** /**
* @brief System event handler * @brief System event handler

37
components/mdns/mdns.c
View File

@ -761,6 +761,7 @@ static uint16_t _mdns_append_a_record(uint8_t * packet, uint16_t * index, uint32
return record_length; return record_length;
} }
#if CONFIG_LWIP_IPV6
/** /**
* @brief appends AAAA record to a packet, incrementing the index * @brief appends AAAA record to a packet, incrementing the index
* *
@ -809,6 +810,7 @@ static uint16_t _mdns_append_aaaa_record(uint8_t * packet, uint16_t * index, uin
record_length += part_length; record_length += part_length;
return record_length; return record_length;
} }
#endif
/** /**
* @brief Append question to packet * @brief Append question to packet
@ -874,6 +876,7 @@ static bool _mdns_if_is_dup(mdns_if_t tcpip_if)
return false; return false;
} }
#if CONFIG_LWIP_IPV6
/** /**
* @brief Check if IPv6 address is NULL * @brief Check if IPv6 address is NULL
*/ */
@ -888,6 +891,7 @@ static bool _ipv6_address_is_zero(esp_ip6_addr_t ip6)
} }
return true; return true;
} }
#endif
/** /**
* @brief Append answer to packet * @brief Append answer to packet
@ -936,7 +940,9 @@ static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_
return 2; return 2;
} }
return 1; return 1;
} else if (answer->type == MDNS_TYPE_AAAA) { }
#if CONFIG_LWIP_IPV6
else if (answer->type == MDNS_TYPE_AAAA) {
struct esp_ip6_addr if_ip6; struct esp_ip6_addr if_ip6;
if (!_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].pcb && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].state != PCB_DUP) { if (!_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].pcb && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].state != PCB_DUP) {
return 0; return 0;
@ -962,6 +968,7 @@ static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_
} }
return 1; return 1;
} }
#endif
return 0; return 0;
} }
@ -1235,11 +1242,14 @@ static mdns_tx_packet_t * _mdns_alloc_packet_default(mdns_if_t tcpip_if, mdns_ip
packet->ip_protocol = ip_protocol; packet->ip_protocol = ip_protocol;
packet->port = MDNS_SERVICE_PORT; packet->port = MDNS_SERVICE_PORT;
if (ip_protocol == MDNS_IP_PROTOCOL_V4) { if (ip_protocol == MDNS_IP_PROTOCOL_V4) {
IP_ADDR4(&packet->dst, 224, 0, 0, 251); IP4_ADDR(&packet->dst.u_addr.ip4, 224, 0, 0, 251);
} else { }
#if CONFIG_LWIP_IPV6
else {
esp_ip_addr_t addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000); esp_ip_addr_t addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000);
memcpy(&packet->dst, &addr, sizeof(esp_ip_addr_t)); memcpy(&packet->dst, &addr, sizeof(esp_ip_addr_t));
} }
#endif
return packet; return packet;
} }
@ -2253,6 +2263,7 @@ static int _mdns_check_a_collision(esp_ip4_addr_t * ip, mdns_if_t tcpip_if)
return 0;//same return 0;//same
} }
#if CONFIG_LWIP_IPV6
/** /**
* @brief Detect IPv6 address collision * @brief Detect IPv6 address collision
*/ */
@ -2286,6 +2297,7 @@ static int _mdns_check_aaaa_collision(esp_ip6_addr_t * ip, mdns_if_t tcpip_if)
} }
return 0;//same return 0;//same
} }
#endif
/** /**
* @brief Check if parsed name is discovery * @brief Check if parsed name is discovery
@ -2678,7 +2690,12 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
parsed_packet->authoritative = header.flags.value == MDNS_FLAGS_AUTHORITATIVE; parsed_packet->authoritative = header.flags.value == MDNS_FLAGS_AUTHORITATIVE;
parsed_packet->distributed = header.flags.value == MDNS_FLAGS_DISTRIBUTED; parsed_packet->distributed = header.flags.value == MDNS_FLAGS_DISTRIBUTED;
parsed_packet->id = header.id; parsed_packet->id = header.id;
#if CONFIG_LWIP_IPV6
ip_addr_copy(parsed_packet->src, packet->src); ip_addr_copy(parsed_packet->src, packet->src);
#else
ip4_addr_copy(parsed_packet->src.u_addr.ip4, packet->src.u_addr.ip4);
#endif
parsed_packet->src_port = packet->src_port; parsed_packet->src_port = packet->src_port;
if (header.questions) { if (header.questions) {
@ -2977,7 +2994,9 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
} }
} }
} else if (type == MDNS_TYPE_AAAA) {//ipv6 }
#if CONFIG_LWIP_IPV6
else if (type == MDNS_TYPE_AAAA) {//ipv6
esp_ip_addr_t ip6; esp_ip_addr_t ip6;
ip6.type = IPADDR_TYPE_V6; ip6.type = IPADDR_TYPE_V6;
memcpy(ip6.u_addr.ip6.addr, data_ptr, MDNS_ANSWER_AAAA_SIZE); memcpy(ip6.u_addr.ip6.addr, data_ptr, MDNS_ANSWER_AAAA_SIZE);
@ -3023,7 +3042,9 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
} }
} }
} else if (type == MDNS_TYPE_A) { }
#endif
else if (type == MDNS_TYPE_A) {
esp_ip_addr_t ip; esp_ip_addr_t ip;
ip.type = IPADDR_TYPE_V4; ip.type = IPADDR_TYPE_V4;
memcpy(&(ip.u_addr.ip4.addr), data_ptr, 4); memcpy(&(ip.u_addr.ip4.addr), data_ptr, 4);
@ -4276,13 +4297,17 @@ esp_err_t mdns_init(void)
} }
#endif #endif
uint8_t i; uint8_t i;
#if CONFIG_LWIP_IPV6
esp_ip6_addr_t tmp_addr6; esp_ip6_addr_t tmp_addr6;
#endif
esp_netif_ip_info_t if_ip_info; esp_netif_ip_info_t if_ip_info;
for (i=0; i<MDNS_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
#if CONFIG_LWIP_IPV6
if (!esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(i), &tmp_addr6) && !_ipv6_address_is_zero(tmp_addr6)) { if (!esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(i), &tmp_addr6) && !_ipv6_address_is_zero(tmp_addr6)) {
_mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V6); _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V6);
} }
#endif
if (!esp_netif_get_ip_info(_mdns_get_esp_netif(i), &if_ip_info) && if_ip_info.ip.addr) { if (!esp_netif_get_ip_info(_mdns_get_esp_netif(i), &if_ip_info) && if_ip_info.ip.addr) {
_mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V4); _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V4);
} }
@ -4818,6 +4843,7 @@ esp_err_t mdns_query_a(const char * name, uint32_t timeout, esp_ip4_addr_t * add
return ESP_ERR_NOT_FOUND; return ESP_ERR_NOT_FOUND;
} }
#if CONFIG_LWIP_IPV6
esp_err_t mdns_query_aaaa(const char * name, uint32_t timeout, esp_ip6_addr_t * addr) esp_err_t mdns_query_aaaa(const char * name, uint32_t timeout, esp_ip6_addr_t * addr)
{ {
mdns_result_t * result = NULL; mdns_result_t * result = NULL;
@ -4850,6 +4876,7 @@ esp_err_t mdns_query_aaaa(const char * name, uint32_t timeout, esp_ip6_addr_t *
mdns_query_results_free(result); mdns_query_results_free(result);
return ESP_ERR_NOT_FOUND; return ESP_ERR_NOT_FOUND;
} }
#endif
#ifdef MDNS_ENABLE_DEBUG #ifdef MDNS_ENABLE_DEBUG

4
components/mdns/mdns_console.c
View File

@ -116,6 +116,7 @@ static void register_mdns_query_a(void)
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
} }
#if CONFIG_LWIP_IPV6
static int cmd_mdns_query_aaaa(int argc, char** argv) static int cmd_mdns_query_aaaa(int argc, char** argv)
{ {
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_a_args); int nerrors = arg_parse(argc, argv, (void**) &mdns_query_a_args);
@ -172,6 +173,7 @@ static void register_mdns_query_aaaa(void)
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
} }
#endif
static struct { static struct {
struct arg_str *instance; struct arg_str *instance;
@ -1049,7 +1051,9 @@ void mdns_console_register(void)
register_mdns_service_remove_all(); register_mdns_service_remove_all();
register_mdns_query_a(); register_mdns_query_a();
#if CONFIG_LWIP_IPV6
register_mdns_query_aaaa(); register_mdns_query_aaaa();
#endif
register_mdns_query_txt(); register_mdns_query_txt();
register_mdns_query_srv(); register_mdns_query_srv();
register_mdns_query_ptr(); register_mdns_query_ptr();

33
components/mdns/mdns_networking.c
View File

@ -40,7 +40,7 @@ static esp_err_t _udp_pcb_main_init(void)
} }
_pcb_main->mcast_ttl = 1; _pcb_main->mcast_ttl = 1;
_pcb_main->remote_port = MDNS_SERVICE_PORT; _pcb_main->remote_port = MDNS_SERVICE_PORT;
ip_addr_copy(_pcb_main->remote_ip, ip_addr_any_type); ip_addr_copy(_pcb_main->remote_ip, *(IP_ANY_TYPE));
udp_recv(_pcb_main, &_udp_recv, _mdns_server); udp_recv(_pcb_main, &_udp_recv, _mdns_server);
return ESP_OK; return ESP_OK;
} }
@ -75,19 +75,21 @@ static esp_err_t _udp_join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protoco
assert(netif); assert(netif);
if (ip_protocol == MDNS_IP_PROTOCOL_V4) { if (ip_protocol == MDNS_IP_PROTOCOL_V4) {
ip_addr_t multicast_addr; ip4_addr_t multicast_addr;
IP_ADDR4(&multicast_addr, 224, 0, 0, 251); IP4_ADDR(&multicast_addr, 224, 0, 0, 251);
if(join){ if(join){
if (igmp_joingroup_netif(netif, (const struct ip4_addr *)&multicast_addr.u_addr.ip4)) { if (igmp_joingroup_netif(netif, &multicast_addr)) {
return ESP_ERR_INVALID_STATE; return ESP_ERR_INVALID_STATE;
} }
} else { } else {
if (igmp_leavegroup_netif(netif, (const struct ip4_addr *)&multicast_addr.u_addr.ip4)) { if (igmp_leavegroup_netif(netif, &multicast_addr)) {
return ESP_ERR_INVALID_STATE; return ESP_ERR_INVALID_STATE;
} }
} }
} else { }
#if CONFIG_LWIP_IPV6
else {
ip_addr_t multicast_addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000); ip_addr_t multicast_addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000);
if(join){ if(join){
@ -100,6 +102,7 @@ static esp_err_t _udp_join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protoco
} }
} }
} }
#endif
return ESP_OK; return ESP_OK;
} }
@ -127,20 +130,29 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip
packet->tcpip_if = MDNS_IF_MAX; packet->tcpip_if = MDNS_IF_MAX;
packet->pb = this_pb; packet->pb = this_pb;
packet->src_port = rport; packet->src_port = rport;
#if CONFIG_LWIP_IPV6
packet->src.type = raddr->type; packet->src.type = raddr->type;
memcpy(&packet->src.u_addr, &raddr->u_addr, sizeof(raddr->u_addr)); memcpy(&packet->src.u_addr, &raddr->u_addr, sizeof(raddr->u_addr));
#else
packet->src.type = IPADDR_TYPE_V4;
memcpy(&packet->src.u_addr.ip4, &raddr->addr, sizeof(ip_addr_t));
#endif
packet->dest.type = packet->src.type; packet->dest.type = packet->src.type;
if (packet->src.type == IPADDR_TYPE_V4) { if (packet->src.type == IPADDR_TYPE_V4) {
packet->ip_protocol = MDNS_IP_PROTOCOL_V4; packet->ip_protocol = MDNS_IP_PROTOCOL_V4;
struct ip_hdr * iphdr = (struct ip_hdr *)(((uint8_t *)(packet->pb->payload)) - UDP_HLEN - IP_HLEN); struct ip_hdr * iphdr = (struct ip_hdr *)(((uint8_t *)(packet->pb->payload)) - UDP_HLEN - IP_HLEN);
packet->dest.u_addr.ip4.addr = iphdr->dest.addr; packet->dest.u_addr.ip4.addr = iphdr->dest.addr;
} else { packet->multicast = ip4_addr_ismulticast(&(packet->dest.u_addr.ip4));
}
#if CONFIG_LWIP_IPV6
else {
packet->ip_protocol = MDNS_IP_PROTOCOL_V6; packet->ip_protocol = MDNS_IP_PROTOCOL_V6;
struct ip6_hdr * ip6hdr = (struct ip6_hdr *)(((uint8_t *)(packet->pb->payload)) - UDP_HLEN - IP6_HLEN); struct ip6_hdr * ip6hdr = (struct ip6_hdr *)(((uint8_t *)(packet->pb->payload)) - UDP_HLEN - IP6_HLEN);
memcpy(&packet->dest.u_addr.ip6.addr, (uint8_t *)ip6hdr->dest.addr, 16); memcpy(&packet->dest.u_addr.ip6.addr, (uint8_t *)ip6hdr->dest.addr, 16);
packet->multicast = ip6_addr_ismulticast(&(packet->dest.u_addr.ip6));
} }
packet->multicast = ip_addr_ismulticast(&(packet->dest)); #endif
//lwip does not return the proper pcb if you have more than one for the same multicast address (but different interfaces) //lwip does not return the proper pcb if you have more than one for the same multicast address (but different interfaces)
struct netif * netif = NULL; struct netif * netif = NULL;
@ -150,8 +162,11 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip
netif = esp_netif_get_netif_impl(_mdns_get_esp_netif(i)); netif = esp_netif_get_netif_impl(_mdns_get_esp_netif(i));
if (pcb && netif && netif == ip_current_input_netif ()) { if (pcb && netif && netif == ip_current_input_netif ()) {
if (packet->src.type == IPADDR_TYPE_V4) { if (packet->src.type == IPADDR_TYPE_V4) {
#if CONFIG_LWIP_IPV6
if ((packet->src.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr) != (netif->ip_addr.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr)) { if ((packet->src.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr) != (netif->ip_addr.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr)) {
//packet source is not in the same subnet #else
if ((packet->src.u_addr.ip4.addr & netif->netmask.addr) != (netif->ip_addr.addr & netif->netmask.addr)) {
#endif //packet source is not in the same subnet
pcb = NULL; pcb = NULL;
break; break;
} }