mdns: fix build issue with CONFIG_LWIP_IPV6 disabled

fix(esp_modem): Correct exit of CMUX mode

components/esp_modem/examples/linux_modem/main/modem_main.cpp

@@ -61,7 +61,7 @@ int main()
 
     bool pin_ok = true;
     if (dce->read_pin(pin_ok) == command_result::OK && !pin_ok) {
-        throw_if_false(dce->set_pin(CONFIG_EXAMPLE_SIM_PIN) == command_result::OK, "Cannot set PIN!");
+        ESP_MODEM_THROW_IF_FALSE(dce->set_pin(CONFIG_EXAMPLE_SIM_PIN) == command_result::OK, "Cannot set PIN!");
         usleep(1000000);
     }
     std::string str;

components/esp_modem/examples/modem_console/components/esp_modem_usb_dte/esp_modem_usb.cpp

@@ -70,9 +70,9 @@ public:
                 .skip_phy_setup = false,
                 .intr_flags = ESP_INTR_FLAG_LEVEL1,
             };
-            throw_if_esp_fail(usb_host_install(&host_config), "USB Host install failed");
+            ESP_MODEM_THROW_IF_ERROR(usb_host_install(&host_config), "USB Host install failed");
             ESP_LOGD(TAG, "USB Host installed");
-            throw_if_false(pdTRUE == xTaskCreatePinnedToCore(usb_host_task, "usb_host", 4096, NULL, config->task_priority + 1, NULL, usb_config->xCoreID), "USB host task failed");
+            ESP_MODEM_THROW_IF_FALSE(pdTRUE == xTaskCreatePinnedToCore(usb_host_task, "usb_host", 4096, NULL, config->task_priority + 1, NULL, usb_config->xCoreID), "USB host task failed");
         }
 
         // Install CDC-ACM driver
@@ -95,11 +95,11 @@ public:
         };
 
         if (usb_config->cdc_compliant) {
-            throw_if_esp_fail(this->CdcAcmDevice::open(usb_config->vid, usb_config->pid,
+            ESP_MODEM_THROW_IF_ERROR(this->CdcAcmDevice::open(usb_config->vid, usb_config->pid,
                             usb_config->interface_idx, &esp_modem_cdc_acm_device_config),
                             "USB Device open failed");
         } else {
-            throw_if_esp_fail(this->CdcAcmDevice::open_vendor_specific(usb_config->vid, usb_config->pid,
+            ESP_MODEM_THROW_IF_ERROR(this->CdcAcmDevice::open_vendor_specific(usb_config->vid, usb_config->pid,
                             usb_config->interface_idx, &esp_modem_cdc_acm_device_config),
                             "USB Device open failed");
         }

components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp

@@ -82,7 +82,7 @@ extern "C" void app_main(void)
 #if CONFIG_EXAMPLE_NEED_SIM_PIN == 1
     bool pin_ok = true;
     if (dce->read_pin(pin_ok) == command_result::OK && !pin_ok) {
-        throw_if_false(dce->set_pin(CONFIG_EXAMPLE_SIM_PIN) == command_result::OK, "Cannot set PIN!");
+        ESP_MODEM_THROW_IF_FALSE(dce->set_pin(CONFIG_EXAMPLE_SIM_PIN) == command_result::OK, "Cannot set PIN!");
         vTaskDelay(pdMS_TO_TICKS(1000)); // Need to wait for some time after unlocking the SIM
     }
 #endif

components/esp_modem/include/cxx_include/esp_modem_dce_factory.hpp

@@ -69,12 +69,12 @@ class Creator {
 public:
     Creator(std::shared_ptr<DTE> dte, esp_netif_t *esp_netif): dte(std::move(dte)), device(nullptr), netif(esp_netif)
     {
-        throw_if_false(netif != nullptr, "Null netif");
+        ESP_MODEM_THROW_IF_FALSE(netif != nullptr, "Null netif");
     }
 
     Creator(std::shared_ptr<DTE> dte, esp_netif_t *esp_netif, std::shared_ptr<T_Module> dev): dte(std::move(dte)), device(std::move(dev)), netif(esp_netif)
     {
-        throw_if_false(netif != nullptr, "Null netif");
+        ESP_MODEM_THROW_IF_FALSE(netif != nullptr, "Null netif");
     }
 
     ~Creator()

components/esp_modem/include/cxx_include/esp_modem_exception.hpp

@@ -16,14 +16,21 @@
 
 #include <string>
 #include "esp_err.h"
+#include "esp_log.h"
+
+#ifndef __FILENAME__
+#define __FILENAME__    __FILE__
+#endif
+#define ESP_MODEM_THROW_IF_FALSE(...) esp_modem::throw_if_false(__FILENAME__, __LINE__, __VA_ARGS__)
+#define ESP_MODEM_THROW_IF_ERROR(...) esp_modem::throw_if_error(__FILENAME__, __LINE__, __VA_ARGS__)
 
 namespace esp_modem {
 
 #ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
-#define THROW(exception) throw(exception)
+#define ESP_MODEM_THROW(exception) throw(exception)
+
 class esp_err_exception: virtual public std::exception {
 public:
-    explicit esp_err_exception(esp_err_t err): esp_err(err) {}
     explicit esp_err_exception(std::string msg): esp_err(ESP_FAIL), message(std::move(msg)) {}
     explicit esp_err_exception(std::string msg, esp_err_t err): esp_err(err), message(std::move(msg)) {}
     virtual esp_err_t get_err_t()
@@ -31,7 +38,7 @@ public:
         return esp_err;
     }
     ~esp_err_exception() noexcept override = default;
-    virtual const char *what() const noexcept
+    [[nodiscard]] const char *what() const noexcept override
     {
         return message.c_str();
     }
@@ -39,28 +46,43 @@ private:
     esp_err_t esp_err;
     std::string message;
 };
+
 #else
-#define THROW(exception) abort()
+#define ESP_MODEM_THROW(exception) do { exception; abort(); } while(0)
+
+class esp_err_exception {
+    void print(std::string msg) { ESP_LOGE("ESP_MODEM_THROW", "%s\n", msg.c_str()); }
+public:
+    explicit esp_err_exception(std::string msg) { print(std::move(msg)); }
+    explicit esp_err_exception(std::string msg, esp_err_t err) { print(std::move(msg)); }
+};
+
 #endif
 
-static inline void throw_if_false(bool condition, std::string message)
+static inline std::string make_message(const std::string& filename, int line, const std::string& message = "ERROR")
+{
+    std::string text = filename + ":" + std::to_string(line) + " " + message;
+    return text;
+}
+
+static inline void throw_if_false(const std::string& filename, int line, bool condition, const std::string& message)
 {
     if (!condition) {
-        THROW(esp_err_exception(std::move(message)));
+        ESP_MODEM_THROW(esp_err_exception(make_message(filename, line, message)));
     }
 }
 
-static inline void throw_if_esp_fail(esp_err_t err, std::string message)
+static inline void throw_if_error(const std::string& filename, int line, esp_err_t err, const std::string& message)
 {
     if (err != ESP_OK) {
-        THROW(esp_err_exception(std::move(message), err));
+        ESP_MODEM_THROW(esp_err_exception(make_message(filename, line, message), err));
     }
 }
 
-static inline void throw_if_esp_fail(esp_err_t err)
+static inline void throw_if_error(const std::string& filename, int line, esp_err_t err)
 {
     if (err != ESP_OK) {
-        THROW(esp_err_exception(err));
+        ESP_MODEM_THROW(esp_err_exception(make_message(filename, line), err));
     }
 }
 

components/esp_modem/src/esp_modem_cmux.cpp

@@ -82,7 +82,7 @@ void CMux::send_disconnect(size_t i)
 {
     if (i == 0) {   // control terminal
         uint8_t frame[] = {
-                SOF_MARKER, 0x3, 0xFF, 0x5, 0xC3, 0x1, 0xE7, SOF_MARKER };
+                SOF_MARKER, 0x3, 0xEF, 0x5, 0xC3, 0x1, 0xF2, SOF_MARKER };
         term->write(frame, 8);
     } else {        // separate virtual terminal
         uint8_t frame[] = {
@@ -142,7 +142,7 @@ void CMux::data_available(uint8_t *data, size_t len)
             read_cb[virtual_term](payload_start, total_payload_size);
 #endif
         }
-    } else if (type == 0xFF && dlci == 0) { // notify the internal DISC command
+    } else if ((type&FT_UIH) == FT_UIH && dlci == 0) { // notify the internal DISC command
         Scoped<Lock> l(lock);
         sabm_ack = dlci;
     }
@@ -325,11 +325,12 @@ bool CMux::on_cmux_data(uint8_t *data, size_t actual_len)
 
 bool CMux::deinit()
 {
-    int timeout = 0;
+    int timeout;
     sabm_ack = -1;
     // First disconnect all (2) virtual terminals
     for (size_t i = 1; i < 3; i++) {
         send_disconnect(i);
+        timeout = 0;
         while (true) {
             usleep(10'000);
             Scoped<Lock> l(lock);
@@ -345,6 +346,7 @@ bool CMux::deinit()
     sabm_ack = -1;
     // Then disconnect the control terminal
     send_disconnect(0);
+    timeout = 0;
     while (true) {
         usleep(10'000);
         Scoped<Lock> l(lock);

components/esp_modem/src/esp_modem_dte.cpp

@@ -56,7 +56,7 @@ command_result DTE::command(const std::string &command, got_line_cb got_line, ui
     command_term->write((uint8_t *)command.c_str(), command.length());
     auto got_lf = signal.wait(GOT_LINE, time_ms);
     if (got_lf && res == command_result::TIMEOUT) {
-        throw_if_esp_fail(ESP_ERR_INVALID_STATE);
+        ESP_MODEM_THROW_IF_ERROR(ESP_ERR_INVALID_STATE);
     }
     buffer.consumed = 0;
     command_term->set_read_cb(nullptr);

components/esp_modem/src/esp_modem_netif.cpp

@@ -82,11 +82,11 @@ Netif::Netif(std::shared_ptr<DTE> e, esp_netif_t *ppp_netif) :
     driver.base.netif = ppp_netif;
     driver.ppp = this;
     driver.base.post_attach = esp_modem_post_attach;
-    throw_if_esp_fail(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, &on_ppp_changed, (void *) this));
-    throw_if_esp_fail(esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_GOT_IP, esp_netif_action_connected, ppp_netif));
-    throw_if_esp_fail(
+    ESP_MODEM_THROW_IF_ERROR(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, &on_ppp_changed, (void *) this));
+    ESP_MODEM_THROW_IF_ERROR(esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_GOT_IP, esp_netif_action_connected, ppp_netif));
+    ESP_MODEM_THROW_IF_ERROR(
         esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_LOST_IP, esp_netif_action_disconnected, ppp_netif));
-    throw_if_esp_fail(esp_netif_attach(ppp_netif, &driver));
+    ESP_MODEM_THROW_IF_ERROR(esp_netif_attach(ppp_netif, &driver));
 }
 
 void Netif::start()

components/esp_modem/src/esp_modem_primitives_freertos.cpp

@@ -28,7 +28,7 @@ void Lock::unlock()
 Lock::Lock(): m(nullptr)
 {
     m = xSemaphoreCreateRecursiveMutex();
-    throw_if_false(m != nullptr, "create signal event group failed");
+    ESP_MODEM_THROW_IF_FALSE(m != nullptr, "create signal event group failed");
 }
 
 Lock::~Lock()
@@ -45,7 +45,7 @@ void Lock::lock()
 SignalGroup::SignalGroup(): event_group(nullptr)
 {
     event_group = xEventGroupCreate();
-    throw_if_false(event_group != nullptr, "create signal event group failed");
+    ESP_MODEM_THROW_IF_FALSE(event_group != nullptr, "create signal event group failed");
 }
 
 void SignalGroup::set(uint32_t bits)
@@ -86,7 +86,7 @@ Task::Task(size_t stack_size, size_t priority, void *task_param, TaskFunction_t
     : task_handle(nullptr)
 {
     BaseType_t ret = xTaskCreate(task_function, "vfs_task", stack_size, task_param, priority, &task_handle);
-    throw_if_false(ret == pdTRUE, "create vfs task failed");
+    ESP_MODEM_THROW_IF_FALSE(ret == pdTRUE, "create vfs task failed");
 }
 
 Task::~Task()

components/esp_modem/src/esp_modem_term_uart.cpp

@@ -40,7 +40,7 @@ uart_resource::uart_resource(const esp_modem_uart_term_config *config, QueueHand
                             : UART_HW_FLOWCTRL_DISABLE;
     uart_config.source_clk = config->source_clk;
 
-    throw_if_esp_fail(uart_param_config(config->port_num, &uart_config), "config uart parameter failed");
+    ESP_MODEM_THROW_IF_ERROR(uart_param_config(config->port_num, &uart_config), "config uart parameter failed");
 
     if (config->flow_control == ESP_MODEM_FLOW_CONTROL_HW) {
         res = uart_set_pin(config->port_num, config->tx_io_num, config->rx_io_num,
@@ -49,24 +49,24 @@ uart_resource::uart_resource(const esp_modem_uart_term_config *config, QueueHand
         res = uart_set_pin(config->port_num, config->tx_io_num, config->rx_io_num,
                            UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
     }
-    throw_if_esp_fail(res, "config uart gpio failed");
+    ESP_MODEM_THROW_IF_ERROR(res, "config uart gpio failed");
     /* Set flow control threshold */
     if (config->flow_control == ESP_MODEM_FLOW_CONTROL_HW) {
         res = uart_set_hw_flow_ctrl(config->port_num, UART_HW_FLOWCTRL_CTS_RTS, UART_FIFO_LEN - 8);
     } else if (config->flow_control == ESP_MODEM_FLOW_CONTROL_SW) {
         res = uart_set_sw_flow_ctrl(config->port_num, true, 8, UART_FIFO_LEN - 8);
     }
-    throw_if_esp_fail(res, "config uart flow control failed");
+    ESP_MODEM_THROW_IF_ERROR(res, "config uart flow control failed");
 
     /* Install UART driver and get event queue used inside driver */
     res = uart_driver_install(config->port_num,
                               config->rx_buffer_size, config->tx_buffer_size,
                               config->event_queue_size, config->event_queue_size ?  event_queue : nullptr,
                               0);
-    throw_if_esp_fail(res, "install uart driver failed");
-    throw_if_esp_fail(uart_set_rx_timeout(config->port_num, 1), "set rx timeout failed");
+    ESP_MODEM_THROW_IF_ERROR(res, "install uart driver failed");
+    ESP_MODEM_THROW_IF_ERROR(uart_set_rx_timeout(config->port_num, 1), "set rx timeout failed");
 
-    throw_if_esp_fail(uart_set_rx_full_threshold(config->port_num, 64), "config rx full threshold failed");
+    ESP_MODEM_THROW_IF_ERROR(uart_set_rx_full_threshold(config->port_num, 64), "config rx full threshold failed");
 
     /* mark UART as initialized */
     port = config->port_num;

components/esp_modem/src/esp_modem_uart.cpp

@@ -33,7 +33,7 @@ struct uart_task {
         task_handle(nullptr)
     {
         BaseType_t ret = xTaskCreate(task_function, "uart_task", stack_size, task_param, priority, &task_handle);
-        throw_if_false(ret == pdTRUE, "create uart event task failed");
+        ESP_MODEM_THROW_IF_FALSE(ret == pdTRUE, "create uart event task failed");
     }
 
     ~uart_task()

components/esp_modem/src/esp_modem_uart_linux.cpp

@@ -27,7 +27,7 @@ uart_resource::uart_resource(const esp_modem_uart_term_config *config, QueueHand
 {
     ESP_LOGD(TAG, "Creating uart resource" );
     struct termios tty = {};
-    throw_if_false(tcgetattr(fd, &tty) == 0, "Failed to tcgetattr()");
+    ESP_MODEM_THROW_IF_FALSE(tcgetattr(fd, &tty) == 0, "Failed to tcgetattr()");
 
     tty.c_cflag &= ~PARENB;
     tty.c_cflag &= ~CSTOPB;

components/esp_modem/src/esp_modem_vfs_socket_creator.cpp

@@ -91,7 +91,7 @@ bool vfs_create_socket(struct esp_modem_vfs_socket_creator *config, struct esp_m
     }
     TRY_CATCH_OR_DO(
         int fd = -1;
-        esp_modem::throw_if_esp_fail(hostname_to_fd(config->host_name, config->port, &fd));
+        ESP_MODEM_THROW_IF_ERROR(hostname_to_fd(config->host_name, config->port, &fd));
 
         // Set the FD to non-blocking mode
         int flags = fcntl(fd, F_GETFL, nullptr) | O_NONBLOCK;

components/esp_modem/src/esp_modem_vfs_uart_creator.cpp

@@ -48,7 +48,7 @@ bool vfs_create_uart(struct esp_modem_vfs_uart_creator *config, struct esp_modem
     }
     TRY_CATCH_OR_DO(
         int fd = open(config->dev_name, O_RDWR);
-        esp_modem::throw_if_false(fd >= 0, "Cannot open the fd");
+        ESP_MODEM_THROW_IF_FALSE(fd >= 0, "Cannot open the fd");
 
         created_config->resource = new esp_modem_vfs_resource(&config->uart, fd);
         created_config->fd = fd;

components/mdns/examples/CMakeLists.txt

@@ -2,7 +2,7 @@
 # in this exact order for cmake to work correctly
 cmake_minimum_required(VERSION 3.5)
 
-set(EXTRA_COMPONENT_DIRS "../..")
+set(EXTRA_COMPONENT_DIRS "..")
 # This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.
 list(APPEND EXTRA_COMPONENT_DIRS "../../../common_components/protocol_examples_common")
 

components/mdns/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.0.5"
+version: "1.0.6"
 description: mDNS
 dependencies:
   idf:

components/mdns/mdns.c

@@ -1686,7 +1686,7 @@ static void _mdns_create_answer_from_parsed_packet(mdns_parsed_packet_t *parsed_
     if (!packet) {
         return;
     }
-    packet->flags = MDNS_FLAGS_AUTHORITATIVE;
+    packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE;
     packet->distributed = parsed_packet->distributed;
     packet->id = parsed_packet->id;
 
@@ -1935,7 +1935,7 @@ static mdns_tx_packet_t * _mdns_create_announce_packet(mdns_if_t tcpip_if, mdns_
     if (!packet) {
         return NULL;
     }
-    packet->flags = MDNS_FLAGS_AUTHORITATIVE;
+    packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE;
 
     uint8_t i;
     for (i=0; i<len; i++) {
@@ -1965,7 +1965,7 @@ static mdns_tx_packet_t * _mdns_create_announce_from_probe(mdns_tx_packet_t * pr
     if (!packet) {
         return NULL;
     }
-    packet->flags = MDNS_FLAGS_AUTHORITATIVE;
+    packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE;
 
     mdns_out_answer_t * s = probe->servers;
     while (s) {
@@ -2005,7 +2005,7 @@ static void _mdns_pcb_send_bye(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protoco
     if (!packet) {
         return;
     }
-    packet->flags = MDNS_FLAGS_AUTHORITATIVE;
+    packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE;
     size_t i;
     for (i=0; i<len; i++) {
         if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, services[i]->service, NULL, true, true)) {
@@ -3342,13 +3342,13 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
     memset(name, 0, sizeof(mdns_name_t));
 
     header.id = _mdns_read_u16(data, MDNS_HEAD_ID_OFFSET);
-    header.flags.value = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET);
+    header.flags = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET);
     header.questions = _mdns_read_u16(data, MDNS_HEAD_QUESTIONS_OFFSET);
     header.answers = _mdns_read_u16(data, MDNS_HEAD_ANSWERS_OFFSET);
     header.servers = _mdns_read_u16(data, MDNS_HEAD_SERVERS_OFFSET);
     header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET);
 
-    if (header.flags.value == MDNS_FLAGS_AUTHORITATIVE && packet->src_port != MDNS_SERVICE_PORT) {
+    if (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE && packet->src_port != MDNS_SERVICE_PORT) {
         free(parsed_packet);
         return;
     }
@@ -3362,8 +3362,8 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
     parsed_packet->tcpip_if = packet->tcpip_if;
     parsed_packet->ip_protocol = packet->ip_protocol;
     parsed_packet->multicast = packet->multicast;
-    parsed_packet->authoritative = header.flags.value == MDNS_FLAGS_AUTHORITATIVE;
-    parsed_packet->distributed = header.flags.value == MDNS_FLAGS_DISTRIBUTED;
+    parsed_packet->authoritative = (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE);
+    parsed_packet->distributed = header.flags == MDNS_FLAGS_DISTRIBUTED;
     parsed_packet->id = header.id;
     esp_netif_ip_addr_copy(&parsed_packet->src, &packet->src);
     parsed_packet->src_port = packet->src_port;
@@ -3499,7 +3499,7 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
                     service = _mdns_get_service_item(name->service, name->proto, NULL);
                 }
             } else {
-                if (!header.flags.qr || record_type == MDNS_NS) {
+                if ((header.flags & MDNS_FLAGS_QUERY_REPSONSE) == 0 || record_type == MDNS_NS) {
                     //skip this record
                     continue;
                 }
@@ -6075,11 +6075,11 @@ void mdns_debug_packet(const uint8_t * data, size_t len)
     header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET);
 
     _mdns_dbg_printf("%s",
-        (header.flags.value == MDNS_FLAGS_AUTHORITATIVE)?"AUTHORITATIVE\n":
+        (header.flags.value == MDNS_FLAGS_QR_AUTHORITATIVE)?"AUTHORITATIVE\n":
         (header.flags.value == MDNS_FLAGS_DISTRIBUTED)?"DISTRIBUTED\n":
         (header.flags.value == 0)?"\n":" "
     );
-    if (header.flags.value && header.flags.value != MDNS_FLAGS_AUTHORITATIVE) {
+    if (header.flags.value && header.flags.value != MDNS_FLAGS_QR_AUTHORITATIVE) {
         _mdns_dbg_printf("0x%04X\n", header.flags.value);
     }
 

components/mdns/mdns_networking_lwip.c

@@ -339,8 +339,12 @@ size_t _mdns_udp_pcb_write(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, c
     memcpy((uint8_t *)pbt->payload, data, len);
 
     ip_addr_t ip_add_copy;
+#if CONFIG_LWIP_IPV6
     ip_add_copy.type = ip->type;
-    memcpy(&(ip_add_copy.u_addr),&(ip->u_addr),sizeof(ip_add_copy.u_addr));
+    memcpy(&(ip_add_copy.u_addr), &(ip->u_addr), sizeof(ip_add_copy.u_addr));
+#else
+    memcpy(&(ip_add_copy.addr), &(ip->u_addr), sizeof(ip_addr_copy.addr));
+#endif // CONFIG_LWIP_IPV6
 
     mdns_api_call_t msg = {
         .tcpip_if = tcpip_if,

components/mdns/private_include/mdns_private.h

@@ -71,7 +71,9 @@
 #define MDNS_ANSWER_A_TTL           120
 #define MDNS_ANSWER_AAAA_TTL        120
 
-#define MDNS_FLAGS_AUTHORITATIVE    0x8400
+#define MDNS_FLAGS_QUERY_REPSONSE   0x8000
+#define MDNS_FLAGS_AUTHORITATIVE    0x0400
+#define MDNS_FLAGS_QR_AUTHORITATIVE (MDNS_FLAGS_QUERY_REPSONSE | MDNS_FLAGS_AUTHORITATIVE)
 #define MDNS_FLAGS_DISTRIBUTED      0x0200
 
 #define MDNS_NAME_REF               0xC000
@@ -211,21 +213,7 @@ typedef enum {
 
 typedef struct {
     uint16_t id;
-    union {
-        struct {
-            uint16_t qr :1;
-            uint16_t opCode :4;
-            uint16_t aa :1;
-            uint16_t tc :1;
-            uint16_t rd :1;
-            uint16_t ra :1;
-            uint16_t z :1;
-            uint16_t ad :1;
-            uint16_t cd :1;
-            uint16_t rCode :4;//response/error code
-        };
-        uint16_t value;
-    } flags;
+    uint16_t flags;
     uint16_t questions; //QDCOUNT
     uint16_t answers;   //ANCOUNT
     uint16_t servers;   //NSCOUNT