/*
 * LEAmDNS_Helpers.cpp
 *
 *  License (MIT license):
 *    Permission is hereby granted, 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.
 *
 */

#include "lwip/igmp.h"

#include "LEAmDNS_lwIPdefs.h"
#include "LEAmDNS_Priv.h"


namespace {

/*
 * strrstr (static)
 *
 * Backwards search for p_pcPattern in p_pcString
 * Based on: https://stackoverflow.com/a/1634398/2778898
 *
 */
const char* strrstr(const char*__restrict p_pcString, const char*__restrict p_pcPattern) {
    
    const char* pcResult = 0;
    
    size_t      stStringLength = (p_pcString ? strlen(p_pcString) : 0);
    size_t      stPatternLength = (p_pcPattern ? strlen(p_pcPattern) : 0);

    if ((stStringLength) &&
        (stPatternLength) &&
        (stPatternLength <= stStringLength)) {
        // Pattern is shorter or has the same length tham the string
        
        for (const char* s=(p_pcString + stStringLength - stPatternLength); s>=p_pcString; --s) {
            if (0 == strncmp(s, p_pcPattern, stPatternLength)) {
                pcResult = s;
                break;
            }
        }
    }
    return pcResult;
}


} // anonymous





namespace esp8266 {

/*
 * LEAmDNS
 */
namespace MDNSImplementation {

/**
 * HELPERS
 */

/*
 * MDNSResponder::indexDomain (static)
 *
 * Updates the given domain 'p_rpcHostname' by appending a delimiter and an index number.
 *
 * If the given domain already hasa numeric index (after the given delimiter), this index
 * incremented. If not, the delimiter and index '2' is added.
 *
 * If 'p_rpcHostname' is empty (==0), the given default name 'p_pcDefaultHostname' is used,
 * if no default is given, 'esp8266' is used.
 *
 */
/*static*/ bool MDNSResponder::indexDomain(char*& p_rpcDomain,
                                           const char* p_pcDivider /*= "-"*/,
                                           const char* p_pcDefaultDomain /*= 0*/) {

    bool    bResult = false;

    // Ensure a divider exists; use '-' as default
    const char*   pcDivider = (p_pcDivider ?: "-");

    if (p_rpcDomain) {
        const char* pFoundDivider = strrstr(p_rpcDomain, pcDivider);
        if (pFoundDivider) {    // maybe already extended
            char*         pEnd = 0;
            unsigned long ulIndex = strtoul((pFoundDivider + strlen(pcDivider)), &pEnd, 10);
            if ((ulIndex) &&
                ((pEnd - p_rpcDomain) == (ptrdiff_t)strlen(p_rpcDomain)) &&
                (!*pEnd)) {       // Valid (old) index found

                char    acIndexBuffer[16];
                sprintf(acIndexBuffer, "%lu", (++ulIndex));
                size_t  stLength = ((pFoundDivider - p_rpcDomain + strlen(pcDivider)) + strlen(acIndexBuffer) + 1);
                char*   pNewHostname = new char[stLength];
                if (pNewHostname) {
                    memcpy(pNewHostname, p_rpcDomain, (pFoundDivider - p_rpcDomain + strlen(pcDivider)));
                    pNewHostname[pFoundDivider - p_rpcDomain + strlen(pcDivider)] = 0;
                    strcat(pNewHostname, acIndexBuffer);

                    delete[] p_rpcDomain;
                    p_rpcDomain = pNewHostname;

                    bResult = true;
                }
                else {
                    DEBUG_EX_ERR(DEBUG_OUTPUT.println(F("[MDNSResponder] indexDomain: FAILED to alloc new hostname!")););
                }
            }
            else {
                pFoundDivider = 0;  // Flag the need to (base) extend the hostname
            }
        }

        if (!pFoundDivider) {   // not yet extended (or failed to increment extension) -> start indexing
            size_t    stLength = strlen(p_rpcDomain) + (strlen(pcDivider) + 1 + 1);   // Name + Divider + '2' + '\0'
            char*     pNewHostname = new char[stLength];
            if (pNewHostname) {
                sprintf(pNewHostname, "%s%s2", p_rpcDomain, pcDivider);

                delete[] p_rpcDomain;
                p_rpcDomain = pNewHostname;

                bResult = true;
            }
            else {
                DEBUG_EX_ERR(DEBUG_OUTPUT.println(F("[MDNSResponder] indexDomain: FAILED to alloc new hostname!")););
            }
        }
    }
    else {
        // No given host domain, use base or default
        const char* cpcDefaultName = (p_pcDefaultDomain ?: "esp8266");

        size_t      stLength = strlen(cpcDefaultName) + 1;   // '\0'
        p_rpcDomain = new char[stLength];
        if (p_rpcDomain) {
            strncpy(p_rpcDomain, cpcDefaultName, stLength);
            bResult = true;
        }
        else {
            DEBUG_EX_ERR(DEBUG_OUTPUT.println(F("[MDNSResponder] indexDomain: FAILED to alloc new hostname!")););
        }
    }
    DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] indexDomain: %s\n"), p_rpcDomain););
    return bResult;
}


/*
 * UDP CONTEXT
 */

bool MDNSResponder::_callProcess(void) {
    DEBUG_EX_INFO(DEBUG_OUTPUT.printf("[MDNSResponder] _callProcess (%lu, triggered by: %s)\n", millis(), IPAddress(m_pUDPContext->getRemoteAddress()).toString().c_str()););

    return _process(false);
}

/*
 * MDNSResponder::_allocUDPContext
 *
 * (Re-)Creates the one-and-only UDP context for the MDNS responder.
 * The context is added to the 'multicast'-group and listens to the MDNS port (5353).
 * The travel-distance for multicast messages is set to 1 (local, via MDNS_MULTICAST_TTL).
 * Messages are received via the MDNSResponder '_update' function. CAUTION: This function
 * is called from the WiFi stack side of the ESP stack system.
 *
 */
bool MDNSResponder::_allocUDPContext(void) {
    DEBUG_EX_INFO(DEBUG_OUTPUT.println("[MDNSResponder] _allocUDPContext"););
    
    bool    bResult = false;
    
    _releaseUDPContext();

#ifdef MDNS_IP4_SUPPORT
    ip_addr_t   multicast_addr = DNS_MQUERY_IPV4_GROUP_INIT;
#endif
#ifdef MDNS_IP6_SUPPORT
    //TODO: set multicast address (lwip_joingroup() is IPv4 only at the time of writing)
    multicast_addr.addr = DNS_MQUERY_IPV6_GROUP_INIT;
#endif
    if (ERR_OK == igmp_joingroup(ip_2_ip4(&m_netif->ip_addr), ip_2_ip4(&multicast_addr))) {
        m_pUDPContext = new UdpContext;
        m_pUDPContext->ref();

        if (m_pUDPContext->listen(IP4_ADDR_ANY, DNS_MQUERY_PORT)) {
            m_pUDPContext->setMulticastTTL(MDNS_MULTICAST_TTL);
            m_pUDPContext->onRx(std::bind(&MDNSResponder::_callProcess, this));
            
            bResult = m_pUDPContext->connect(&multicast_addr, DNS_MQUERY_PORT);
        }
    }
    return bResult;
}

/*
 * MDNSResponder::_releaseUDPContext
 */
bool MDNSResponder::_releaseUDPContext(void) {

    if (m_pUDPContext) {
        m_pUDPContext->unref();
        m_pUDPContext = 0;
    }
    return true;
}


/*
 * SERVICE QUERY
 */

/*
 * MDNSResponder::_allocServiceQuery
 */
MDNSResponder::stcMDNSServiceQuery* MDNSResponder::_allocServiceQuery(void) {
    
    stcMDNSServiceQuery*    pServiceQuery = new stcMDNSServiceQuery;
    if (pServiceQuery) {
        // Link to query list
        pServiceQuery->m_pNext = m_pServiceQueries;
        m_pServiceQueries = pServiceQuery;
    }
    return m_pServiceQueries;
}

/*
 * MDNSResponder::_removeServiceQuery
 */
bool MDNSResponder::_removeServiceQuery(MDNSResponder::stcMDNSServiceQuery* p_pServiceQuery) {
    
    bool    bResult = false;
    
    if (p_pServiceQuery) {
        stcMDNSServiceQuery*    pPred = m_pServiceQueries;
        while ((pPred) &&
               (pPred->m_pNext != p_pServiceQuery)) {
            pPred = pPred->m_pNext;
        }
        if (pPred) {
            pPred->m_pNext = p_pServiceQuery->m_pNext;
            delete p_pServiceQuery;
            bResult = true;
        }
        else {  // No predecesor
            if (m_pServiceQueries == p_pServiceQuery) {
                m_pServiceQueries = p_pServiceQuery->m_pNext;
                delete p_pServiceQuery;
                bResult = true;
            }
            else {
                DEBUG_EX_ERR(DEBUG_OUTPUT.println("[MDNSResponder] _releaseServiceQuery: INVALID service query!"););
            }
        }
    }
    return bResult;
}

/*
 * MDNSResponder::_removeLegacyServiceQuery
 */
bool MDNSResponder::_removeLegacyServiceQuery(void) {
    
    stcMDNSServiceQuery*    pLegacyServiceQuery = _findLegacyServiceQuery();
    return (pLegacyServiceQuery ? _removeServiceQuery(pLegacyServiceQuery) : true);
}

/*
 * MDNSResponder::_findServiceQuery
 *
 * 'Convert' hMDNSServiceQuery to stcMDNSServiceQuery* (ensure existance)
 *
 */
MDNSResponder::stcMDNSServiceQuery* MDNSResponder::_findServiceQuery(MDNSResponder::hMDNSServiceQuery p_hServiceQuery) {
    
    stcMDNSServiceQuery*    pServiceQuery = m_pServiceQueries;
    while (pServiceQuery) {
        if ((hMDNSServiceQuery)pServiceQuery == p_hServiceQuery) {
            break;
        }
        pServiceQuery = pServiceQuery->m_pNext;
    }
    return pServiceQuery;
}

/*
 * MDNSResponder::_findLegacyServiceQuery
 */
MDNSResponder::stcMDNSServiceQuery* MDNSResponder::_findLegacyServiceQuery(void) {
    
    stcMDNSServiceQuery*    pServiceQuery = m_pServiceQueries;
    while (pServiceQuery) {
        if (pServiceQuery->m_bLegacyQuery) {
            break;
        }
        pServiceQuery = pServiceQuery->m_pNext;
    }
    return pServiceQuery;
}

/*
 * MDNSResponder::_releaseServiceQueries
 */
bool MDNSResponder::_releaseServiceQueries(void) {
    while (m_pServiceQueries) {
        stcMDNSServiceQuery*    pNext = m_pServiceQueries->m_pNext;
        delete m_pServiceQueries;
        m_pServiceQueries = pNext;
    }
    return true;
}

/*
 * MDNSResponder::_findNextServiceQueryByServiceType
 */
MDNSResponder::stcMDNSServiceQuery* MDNSResponder::_findNextServiceQueryByServiceType(const stcMDNS_RRDomain& p_ServiceTypeDomain,
                                                                                      const stcMDNSServiceQuery* p_pPrevServiceQuery) {
    stcMDNSServiceQuery*    pMatchingServiceQuery = 0;

    stcMDNSServiceQuery*    pServiceQuery = (p_pPrevServiceQuery ? p_pPrevServiceQuery->m_pNext : m_pServiceQueries);
    while (pServiceQuery) {
        if (p_ServiceTypeDomain == pServiceQuery->m_ServiceTypeDomain) {
            pMatchingServiceQuery = pServiceQuery;
            break;
        }
        pServiceQuery = pServiceQuery->m_pNext;
    }
    return pMatchingServiceQuery;
}


/*
 * HOSTNAME
 */

/*
 * MDNSResponder::_setHostname
 */
bool MDNSResponder::_setHostname(const char* p_pcHostname) {
    //DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _allocHostname (%s)\n"), p_pcHostname););
    
    bool    bResult = false;
    
    _releaseHostname();
    
    size_t  stLength = 0;
    if ((p_pcHostname) &&
        (MDNS_DOMAIN_LABEL_MAXLENGTH >= (stLength = strlen(p_pcHostname)))) { // char max size for a single label
        // Copy in hostname characters as lowercase
        if ((bResult = (0 != (m_pcHostname = new char[stLength + 1])))) {
#ifdef MDNS_FORCE_LOWERCASE_HOSTNAME
            size_t i = 0;
            for (; i<stLength; ++i) {
                m_pcHostname[i] = (isupper(p_pcHostname[i]) ? tolower(p_pcHostname[i]) : p_pcHostname[i]);
            }
            m_pcHostname[i] = 0;
#else
            strncpy(m_pcHostname, p_pcHostname, (stLength + 1));
#endif
        }
    }
    return bResult;
}

/*
 * MDNSResponder::_releaseHostname
 */
bool MDNSResponder::_releaseHostname(void) {
    
    if (m_pcHostname) {
        delete[] m_pcHostname;
        m_pcHostname = 0;
    }
    return true;
}


/*
 * SERVICE
 */

/*
 * MDNSResponder::_allocService
 */
MDNSResponder::stcMDNSService* MDNSResponder::_allocService(const char* p_pcName,
                                                            const char* p_pcService,
                                                            const char* p_pcProtocol,
                                                            uint16_t p_u16Port) {
    
    stcMDNSService* pService = 0;
    if (((!p_pcName) ||
         (MDNS_DOMAIN_LABEL_MAXLENGTH >= strlen(p_pcName))) &&
        (p_pcService) &&
        (MDNS_SERVICE_NAME_LENGTH >= strlen(p_pcService)) &&
        (p_pcProtocol) &&
        (MDNS_SERVICE_PROTOCOL_LENGTH >= strlen(p_pcProtocol)) &&
        (p_u16Port) &&
        (0 != (pService = new stcMDNSService)) &&
        (pService->setName(p_pcName ?: m_pcHostname)) &&
        (pService->setService(p_pcService)) &&
        (pService->setProtocol(p_pcProtocol))) {
        
        pService->m_bAutoName = (0 == p_pcName);
        pService->m_u16Port = p_u16Port;
        
        // Add to list (or start list)
        pService->m_pNext = m_pServices;
        m_pServices = pService;
    }
    return pService;
}

/*
 * MDNSResponder::_releaseService
 */
bool MDNSResponder::_releaseService(MDNSResponder::stcMDNSService* p_pService) {
    
    bool    bResult = false;
    
    if (p_pService) {
        stcMDNSService* pPred = m_pServices;
        while ((pPred) &&
               (pPred->m_pNext != p_pService)) {
            pPred = pPred->m_pNext;
        }
        if (pPred) {
            pPred->m_pNext = p_pService->m_pNext;
            delete p_pService;
            bResult = true;
        }
        else {  // No predecesor
            if (m_pServices == p_pService) {
                m_pServices = p_pService->m_pNext;
                delete p_pService;
                bResult = true;
            }
            else {
                DEBUG_EX_ERR(DEBUG_OUTPUT.println("[MDNSResponder] _releaseService: INVALID service!"););
            }
        }
    }
    return bResult;
}

/*
 * MDNSResponder::_releaseServices
 */
bool MDNSResponder::_releaseServices(void) {
    
    stcMDNSService* pService = m_pServices;
    while (pService) {
        _releaseService(pService);
        pService = m_pServices;
    }
    return true;
}

/*
 * MDNSResponder::_findService
 */
MDNSResponder::stcMDNSService* MDNSResponder::_findService(const char* p_pcName,
                                                           const char* p_pcService,
                                                           const char* p_pcProtocol) {
    
    stcMDNSService* pService = m_pServices;
    while (pService) {
        if ((0 == strcmp(pService->m_pcName, p_pcName)) &&
            (0 == strcmp(pService->m_pcService, p_pcService)) &&
            (0 == strcmp(pService->m_pcProtocol, p_pcProtocol))) {
            
            break;
        }
        pService = pService->m_pNext;
    }
    return pService;
}

/*
 * MDNSResponder::_findService
 */
MDNSResponder::stcMDNSService* MDNSResponder::_findService(const MDNSResponder::hMDNSService p_hService) {
    
    stcMDNSService* pService = m_pServices;
    while (pService) {
        if (p_hService == (hMDNSService)pService) {
            break;
        }
        pService = pService->m_pNext;
    }
    return pService;
}


/*
 * SERVICE TXT
 */

/*
 * MDNSResponder::_allocServiceTxt
 */
MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_allocServiceTxt(MDNSResponder::stcMDNSService* p_pService,
                                                                  const char* p_pcKey,
                                                                  const char* p_pcValue,
                                                                  bool p_bTemp) {

    stcMDNSServiceTxt*  pTxt = 0;
    
    if ((p_pService) &&
        (p_pcKey) &&
        (MDNS_SERVICE_TXT_MAXLENGTH > (p_pService->m_Txts.length() +
                                        1 +                                 // Length byte
                                        (p_pcKey ? strlen(p_pcKey) : 0) +
                                        1 +                                 // '='
                                        (p_pcValue ? strlen(p_pcValue) : 0)))) {
        
        pTxt = new stcMDNSServiceTxt;
        if (pTxt) {
            size_t  stLength = (p_pcKey ? strlen(p_pcKey) : 0);
            pTxt->m_pcKey = new char[stLength + 1];
            if (pTxt->m_pcKey) {
                strncpy(pTxt->m_pcKey, p_pcKey, stLength); pTxt->m_pcKey[stLength] = 0;
            }
            
            if (p_pcValue) {
                stLength = (p_pcValue ? strlen(p_pcValue) : 0);
                pTxt->m_pcValue = new char[stLength + 1];
                if (pTxt->m_pcValue) {
                    strncpy(pTxt->m_pcValue, p_pcValue, stLength); pTxt->m_pcValue[stLength] = 0;
                }
            }
            pTxt->m_bTemp = p_bTemp;
            
            // Add to list (or start list)
            p_pService->m_Txts.add(pTxt);
        }
    }
    return pTxt;
}

/*
 * MDNSResponder::_releaseServiceTxt
 */
bool MDNSResponder::_releaseServiceTxt(MDNSResponder::stcMDNSService* p_pService,
                                       MDNSResponder::stcMDNSServiceTxt* p_pTxt) {
    
    return ((p_pService) &&
            (p_pTxt) &&
            (p_pService->m_Txts.remove(p_pTxt)));
}

/*
 * MDNSResponder::_updateServiceTxt
 */
MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_updateServiceTxt(MDNSResponder::stcMDNSService* p_pService,
                                                                   MDNSResponder::stcMDNSServiceTxt* p_pTxt,
                                                                   const char* p_pcValue,
                                                                   bool p_bTemp) {

    if ((p_pService) &&
        (p_pTxt) &&
        (MDNS_SERVICE_TXT_MAXLENGTH > (p_pService->m_Txts.length() -
                                        (p_pTxt->m_pcValue ? strlen(p_pTxt->m_pcValue) : 0) +
                                        (p_pcValue ? strlen(p_pcValue) : 0)))) {
        p_pTxt->update(p_pcValue);
        p_pTxt->m_bTemp = p_bTemp;
    }
    return p_pTxt;
}

/*
 * MDNSResponder::_findServiceTxt
 */
MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_findServiceTxt(MDNSResponder::stcMDNSService* p_pService,
                                                                 const char* p_pcKey) {
    
    return (p_pService ? p_pService->m_Txts.find(p_pcKey) : 0);
}

/*
 * MDNSResponder::_findServiceTxt
 */
MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_findServiceTxt(MDNSResponder::stcMDNSService* p_pService,
                                                                 const hMDNSTxt p_hTxt) {
    
    return (((p_pService) && (p_hTxt)) ? p_pService->m_Txts.find((stcMDNSServiceTxt*)p_hTxt) : 0);
}

/*
 * MDNSResponder::_addServiceTxt
 */
MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_addServiceTxt(MDNSResponder::stcMDNSService* p_pService,
                                                                const char* p_pcKey,
                                                                const char* p_pcValue,
                                                                bool p_bTemp) {
    stcMDNSServiceTxt*  pResult = 0;
    
    if ((p_pService) &&
        (p_pcKey) &&
        (strlen(p_pcKey))) {
        
        stcMDNSServiceTxt*  pTxt = p_pService->m_Txts.find(p_pcKey);
        if (pTxt) {
            pResult = _updateServiceTxt(p_pService, pTxt, p_pcValue, p_bTemp);
        }
        else {
            pResult = _allocServiceTxt(p_pService, p_pcKey, p_pcValue, p_bTemp);
        }
    }
    return pResult;
}

MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_answerKeyValue(const hMDNSServiceQuery p_hServiceQuery,
                                                                 const uint32_t p_u32AnswerIndex) {
    stcMDNSServiceQuery*            pServiceQuery = _findServiceQuery(p_hServiceQuery);
    stcMDNSServiceQuery::stcAnswer* pSQAnswer = (pServiceQuery ? pServiceQuery->answerAtIndex(p_u32AnswerIndex) : 0);
    // Fill m_pcTxts (if not already done)
    return (pSQAnswer) ?  pSQAnswer->m_Txts.m_pTxts : 0;
}

/*
 * MDNSResponder::_collectServiceTxts
 */
bool MDNSResponder::_collectServiceTxts(MDNSResponder::stcMDNSService& p_rService) {
    
	// Call Dynamic service callbacks
    if (m_fnServiceTxtCallback) {
    	m_fnServiceTxtCallback((hMDNSService)&p_rService);
    }
    if (p_rService.m_fnTxtCallback) {
        p_rService.m_fnTxtCallback((hMDNSService)&p_rService);
    }
    return true;
}

/*
 * MDNSResponder::_releaseTempServiceTxts
 */
bool MDNSResponder::_releaseTempServiceTxts(MDNSResponder::stcMDNSService& p_rService) {
    
    return (p_rService.m_Txts.removeTempTxts());
}


/*
 * MISC
 */

#ifdef DEBUG_ESP_MDNS_RESPONDER
    /*
     * MDNSResponder::_printRRDomain
     */
    bool MDNSResponder::_printRRDomain(const MDNSResponder::stcMDNS_RRDomain& p_RRDomain) const {

        //DEBUG_OUTPUT.printf_P(PSTR("Domain: "));

        const char* pCursor = p_RRDomain.m_acName;
        uint8_t     u8Length = *pCursor++;
        if (u8Length) {
            while (u8Length) {
                for (uint8_t u=0; u<u8Length; ++u) {
                    DEBUG_OUTPUT.printf_P(PSTR("%c"), *(pCursor++));
                }
                u8Length = *pCursor++;
                if (u8Length) {
                    DEBUG_OUTPUT.printf_P(PSTR("."));
                }
            }
        }
        else {  // empty domain
            DEBUG_OUTPUT.printf_P(PSTR("-empty-"));
        }
        //DEBUG_OUTPUT.printf_P(PSTR("\n"));

        return true;
    }

    /*
     * MDNSResponder::_printRRAnswer
     */
    bool MDNSResponder::_printRRAnswer(const MDNSResponder::stcMDNS_RRAnswer& p_RRAnswer) const {

        DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] RRAnswer: "));
        _printRRDomain(p_RRAnswer.m_Header.m_Domain);
        DEBUG_OUTPUT.printf_P(PSTR(" Type:0x%04X Class:0x%04X TTL:%u, "), p_RRAnswer.m_Header.m_Attributes.m_u16Type, p_RRAnswer.m_Header.m_Attributes.m_u16Class, p_RRAnswer.m_u32TTL);
        switch (p_RRAnswer.m_Header.m_Attributes.m_u16Type & (~0x8000)) {   // Topmost bit might carry 'cache flush' flag
#ifdef MDNS_IP4_SUPPORT
        case DNS_RRTYPE_A:
            DEBUG_OUTPUT.printf_P(PSTR("A IP:%s"), ((const stcMDNS_RRAnswerA*)&p_RRAnswer)->m_IPAddress.toString().c_str());
            break;
#endif
        case DNS_RRTYPE_PTR:
            DEBUG_OUTPUT.printf_P(PSTR("PTR "));
            _printRRDomain(((const stcMDNS_RRAnswerPTR*)&p_RRAnswer)->m_PTRDomain);
            break;
        case DNS_RRTYPE_TXT: {
            size_t  stTxtLength = ((const stcMDNS_RRAnswerTXT*)&p_RRAnswer)->m_Txts.c_strLength();
            char*   pTxts = new char[stTxtLength];
            if (pTxts) {
                ((/*const c_str()!!*/stcMDNS_RRAnswerTXT*)&p_RRAnswer)->m_Txts.c_str(pTxts);
                DEBUG_OUTPUT.printf_P(PSTR("TXT(%u) %s"), stTxtLength, pTxts);
                delete[] pTxts;
            }
            break;
        }
#ifdef MDNS_IP6_SUPPORT
        case DNS_RRTYPE_AAAA:
            DEBUG_OUTPUT.printf_P(PSTR("AAAA IP:%s"), ((stcMDNS_RRAnswerA*&)p_rpRRAnswer)->m_IPAddress.toString().c_str());
            break;
#endif
        case DNS_RRTYPE_SRV:
            DEBUG_OUTPUT.printf_P(PSTR("SRV Port:%u "), ((const stcMDNS_RRAnswerSRV*)&p_RRAnswer)->m_u16Port);
            _printRRDomain(((const stcMDNS_RRAnswerSRV*)&p_RRAnswer)->m_SRVDomain);
            break;
        default:
            DEBUG_OUTPUT.printf_P(PSTR("generic "));
            break;
        }
        DEBUG_OUTPUT.printf_P(PSTR("\n"));

        return true;
    }
#endif

}   // namespace MDNSImplementation

} // namespace esp8266