From 56746037358347e4649f302e45cbccd6c4b0e239 Mon Sep 17 00:00:00 2001 From: hreintke Date: Wed, 23 Jan 2019 13:13:55 +0100 Subject: [PATCH 01/24] Functional update, host and service probes --- .../mDNS_ServiceMonitor.ino | 83 +++++++++++-------- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 18 ++-- libraries/ESP8266mDNS/src/LEAmDNS.h | 73 ++++++++++++---- libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp | 47 +++-------- libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp | 8 +- 5 files changed, 134 insertions(+), 95 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 1bfe7c3802..981cb0f4d5 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -85,8 +85,6 @@ bool setStationHostname(const char* p_pcHostname) { } return true; } - - /* MDNSServiceQueryCallback */ @@ -97,7 +95,7 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder, bool p_bSetContent, // true: Component set, false: component deleted void* p_pUserdata) { // pUserdata; here '0', as none set via 'installServiceQuery' (void) p_pUserdata; - Serial.printf("MDNSServiceQueryCallback\n"); + Serial.printf("MDNSServiceQueryCallback %8d\n",millis()); if ((p_pMDNSResponder) && (hMDNSServiceQuery == p_hServiceQuery)) { @@ -119,11 +117,12 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder, } } else if (MDNSResponder::ServiceQueryAnswerType_IP4Address & p_u32ServiceQueryAnswerMask) { if (p_bSetContent) { - Serial.printf("MDNSServiceQueryCallback: IP4 address added/updated for service '%s':\n", + Serial.printf("MDNSServiceQueryCallback: IP4 address added/updated for service '%s': ", p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); for (uint32_t u = 0; u < p_pMDNSResponder->answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u) { - Serial.printf("- %s\n", p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u).toString().c_str()); + Serial.printf("- %s ", p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u).toString().c_str()); } + Serial.printf("\n"); } else { Serial.printf("MDNSServiceQueryCallback: IP4 address removed from service '%s'\n", p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); @@ -181,7 +180,22 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder, } /* - MDNSProbeResultCallback + MDNSServiceProbeResultCallback + Probe result callback for Services +*/ + +bool serviceProbeResult (String p_pcServiceName, + const MDNSResponder::hMDNSService p_hMDNSService, + bool p_bProbeResult) +{ + Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); + +} + + + +/* + MDNSHostProbeResultCallback Probe result callback for the host domain. If the domain is free, the host domain is set and the http service is @@ -190,17 +204,10 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder, restarted via p_pMDNSResponder->setHostname(). */ -bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder, - const char* p_pcDomainName, - const MDNSResponder::hMDNSService p_hService, - bool p_bProbeResult, - void* p_pUserdata) { - (void) p_pUserdata; - if ((p_pMDNSResponder) && - (0 == p_hService)) { // Called for host domain +bool hostProbeResult (String p_pcDomainName, bool p_bProbeResult) { - Serial.printf("MDNSProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName, (p_bProbeResult ? "free" : "already USED!")); + Serial.printf("MDNSHostProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); if (true == p_bProbeResult) { // Set station hostname @@ -212,18 +219,20 @@ bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder, if (!hMDNSService) { // Add a 'http.tcp' service to port 'SERVICE_PORT', using the host domain as instance domain - hMDNSService = p_pMDNSResponder->addService(0, "http", "tcp", SERVICE_PORT); + hMDNSService = MDNS.addService(0, "http", "tcp", SERVICE_PORT); if (hMDNSService) { + MDNS.setServiceProbeResultCallback(hMDNSService, serviceProbeResult); + // Add some '_http._tcp' protocol specific MDNS service TXT items // See: http://www.dns-sd.org/txtrecords.html#http - p_pMDNSResponder->addServiceTxt(hMDNSService, "user", ""); - p_pMDNSResponder->addServiceTxt(hMDNSService, "password", ""); - p_pMDNSResponder->addServiceTxt(hMDNSService, "path", "/"); + MDNS.addServiceTxt(hMDNSService, "user", ""); + MDNS.addServiceTxt(hMDNSService, "password", ""); + MDNS.addServiceTxt(hMDNSService, "path", "/"); } // Install dynamic 'http.tcp' service query if (!hMDNSServiceQuery) { - hMDNSServiceQuery = p_pMDNSResponder->installServiceQuery("http", "tcp", MDNSServiceQueryCallback, 0); + hMDNSServiceQuery = MDNS.installServiceQuery("http", "tcp", MDNSServiceQueryCallback, 0); if (hMDNSServiceQuery) { Serial.printf("MDNSProbeResultCallback: Service query for 'http.tcp' services installed.\n"); } else { @@ -233,14 +242,14 @@ bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder, } } } else { - // Change hostname, use '-' as divider between base name and index - if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { - p_pMDNSResponder->setHostname(pcHostDomain); - } else { - Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); + // Change hostname, use '-' as divider between base name and index + if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { + MDNS.setHostname(pcHostDomain); + } else { + Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); + } } - } - } + return true; } @@ -251,15 +260,19 @@ void handleHTTPRequest() { Serial.println(""); Serial.println("HTTP Request"); + IPAddress ip = WiFi.localIP(); + String ipStr = String(ip[0]) + '.' + String(ip[1]) + '.' + String(ip[2]) + '.' + String(ip[3]); String s = "\r\n

Hello from "; - s += WiFi.hostname() + ".local at " + WiFi.localIP().toString() + "

"; + s += WiFi.hostname() + ".local at " + ipStr + ""; s += "

Local HTTP services are :

    "; s += strHTTPServices; // done :-) - s += "
"; + s += "
"; + Serial.println("Sending 200"); server.send(200, "text/html", s); Serial.println("Done with request"); + Serial.printf("FM %d\n",ESP.getFreeHeap()); } /* @@ -288,8 +301,10 @@ void setup(void) { // Setup HTTP server server.on("/", handleHTTPRequest); - // Setup MDNS responder - MDNS.setProbeResultCallback(MDNSProbeResultCallback, 0); + // Setup MDNS responders + MDNS.setHostProbeResultCallback(hostProbeResult); + + // Init the (currently empty) host domain string with 'esp8266' if ((!MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || (!MDNS.begin(pcHostDomain))) { @@ -305,13 +320,11 @@ void setup(void) { Serial.println("HTTP server started"); } - -/* - loop -*/ void loop(void) { // Check if a request has come in server.handleClient(); // Allow MDNS processing MDNS.update(); + } + diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index 43e1a802d9..9d4ff6a84e 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -1030,11 +1030,11 @@ const char* MDNSResponder::answerTxts(const MDNSResponder::hMDNSServiceQuery p_h * When succeeded, the host or service domain will be announced by the MDNS responder. * */ -bool MDNSResponder::setProbeResultCallback(MDNSResponder::MDNSProbeResultCallbackFn p_fnCallback, - void* p_pUserdata) { - - m_HostProbeInformation.m_fnProbeResultCallback = p_fnCallback; - m_HostProbeInformation.m_pProbeResultCallbackUserdata = p_pUserdata; +//Functional +bool MDNSResponder::setHostProbeResultCallback(MDNSResponder::MDNSHostProbeResultCallbackFn p_fnCallback) { + + m_HostProbeInformation.m_fnHostProbeResultCallback = p_fnCallback; + m_HostProbeInformation.m_pProbeResultCallbackUserdata = 0; return true; } @@ -1049,14 +1049,14 @@ bool MDNSResponder::setProbeResultCallback(MDNSResponder::MDNSProbeResultCallbac * */ bool MDNSResponder::setServiceProbeResultCallback(const MDNSResponder::hMDNSService p_hService, - MDNSResponder::MDNSProbeResultCallbackFn p_fnCallback, - void* p_pUserdata) { + MDNSResponder::MDNSServiceProbeResultCallbackFn p_fnCallback) { + bool bResult = false; stcMDNSService* pService = _findService(p_hService); if (pService) { - pService->m_ProbeInformation.m_fnProbeResultCallback = p_fnCallback; - pService->m_ProbeInformation.m_pProbeResultCallbackUserdata = p_pUserdata; + pService->m_ProbeInformation.m_fnServiceProbeResultCallback = p_fnCallback; + pService->m_ProbeInformation.m_pProbeResultCallbackUserdata = 0; bResult = true; } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index f5a6702707..684f439640 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -422,24 +422,26 @@ class MDNSResponder { /** * MDNSProbeResultCallbackFn * Callback function for (host and service domain) probe results - */ - typedef bool (*MDNSProbeResultCallbackFn)(MDNSResponder* p_pMDNSResponder, - const char* p_pcDomainName, - const hMDNSService p_hMDNSService, // 0 for host domain - bool p_bProbeResult, - void* p_pUserdata); + */ +// Functional + typedef std::function MDNSHostProbeResultCallbackFn; + + typedef std::function MDNSServiceProbeResultCallbackFn; // Set a global callback function for host and service probe results - // The callback function is called, when the probeing for the host domain + // The callback function is called, when the probing for the host domain // (or a service domain, which hasn't got a service specific callback) - // Succeededs or fails. + // Succeeds or fails. // In case of failure, the failed domain name should be changed. - bool setProbeResultCallback(MDNSProbeResultCallbackFn p_fnCallback, - void* p_pUserdata); - // Set a service specific probe result callcack - bool setServiceProbeResultCallback(const hMDNSService p_hService, - MDNSProbeResultCallbackFn p_fnCallback, - void* p_pUserdata); +// Functional + bool setHostProbeResultCallback(MDNSHostProbeResultCallbackFn p_fnCallback); + + // Set a service specific probe result callback + bool setServiceProbeResultCallback(const MDNSResponder::hMDNSService p_hService, + MDNSServiceProbeResultCallbackFn p_fnCallback); // Application should call this whenever AP is configured/disabled bool notifyAPChange(void); @@ -462,6 +464,45 @@ class MDNSResponder { protected: /** STRUCTS **/ +// Functional + /** + * MDNSServiceInfo, used in application callbacks + */ + struct MDNSServiceInfo + { + MDNSServiceInfo(MDNSResponder* p_pM,MDNSResponder::hMDNSServiceQuery p_hS,uint32_t p_u32A) + : p_pMDNSResponder(p_pM), + p_hServiceQuery(p_hS), + p_u32AnswerIndex(p_u32A) + {}; + MDNSResponder* p_pMDNSResponder; + MDNSResponder::hMDNSServiceQuery p_hServiceQuery; + uint32_t p_u32AnswerIndex; + const char* serviceDomain(){ + return p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex); + }; + const char* hostDomain(){ + return (p_pMDNSResponder->hasAnswerHostDomain(p_hServiceQuery, p_u32AnswerIndex)) ? + p_pMDNSResponder->answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : 0; + }; + uint16_t hostPort(){ + return (p_pMDNSResponder->hasAnswerPort(p_hServiceQuery, p_u32AnswerIndex)) ? + p_pMDNSResponder->answerPort(p_hServiceQuery, p_u32AnswerIndex) : 0; + }; + std::vector IPAdresses(){ + std::vector internalIP; + if (p_pMDNSResponder->hasAnswerIP4Address(p_hServiceQuery,p_u32AnswerIndex )) { + for (uint32_t u2 = 0; u2 < p_pMDNSResponder->answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u2) { + internalIP.push_back(p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u2)); + } + } + return internalIP; + }; + const char* txtValue (){ + return (p_pMDNSResponder->hasAnswerTxts(p_hServiceQuery, p_u32AnswerIndex)) ? + p_pMDNSResponder->answerTxts(p_hServiceQuery, p_u32AnswerIndex) : 0; + }; + }; /** * stcMDNSServiceTxt */ @@ -792,7 +833,9 @@ class MDNSResponder { //clsMDNSTimeFlag m_TimeFlag; // Used for probes and announcements bool m_bConflict; bool m_bTiebreakNeeded; - MDNSProbeResultCallbackFn m_fnProbeResultCallback; +// Functional + MDNSHostProbeResultCallbackFn m_fnHostProbeResultCallback; + MDNSServiceProbeResultCallbackFn m_fnServiceProbeResultCallback; void* m_pProbeResultCallbackUserdata; stcProbeInformation(void); diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp index 61c8e91fcd..b17b468f7e 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp @@ -1060,9 +1060,9 @@ bool MDNSResponder::_updateProbeStatus(void) { DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done host probing.\n"));); m_HostProbeInformation.m_ProbingStatus = ProbingStatus_Done; m_HostProbeInformation.m_Timeout.reset(std::numeric_limits::max()); - - if (m_HostProbeInformation.m_fnProbeResultCallback) { - m_HostProbeInformation.m_fnProbeResultCallback(this, m_pcHostname, 0, true, m_HostProbeInformation.m_pProbeResultCallbackUserdata); +// Functional + if (m_HostProbeInformation.m_fnHostProbeResultCallback) { + m_HostProbeInformation.m_fnHostProbeResultCallback(m_pcHostname, true); } // Prepare to announce host @@ -1110,21 +1110,10 @@ bool MDNSResponder::_updateProbeStatus(void) { DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done service probing %s.%s.%s\n\n"), (pService->m_pcName ?: m_pcHostname), pService->m_pcService, pService->m_pcProtocol);); pService->m_ProbeInformation.m_ProbingStatus = ProbingStatus_Done; pService->m_ProbeInformation.m_Timeout.reset(std::numeric_limits::max()); - - MDNSProbeResultCallbackFn fnProbeResultCallback = 0; - void* pProbeResultCallbackUserdata = 0; - if (pService->m_ProbeInformation.m_fnProbeResultCallback) { - fnProbeResultCallback = pService->m_ProbeInformation.m_fnProbeResultCallback; - pProbeResultCallbackUserdata = pService->m_ProbeInformation.m_pProbeResultCallbackUserdata; - } - else { - fnProbeResultCallback = m_HostProbeInformation.m_fnProbeResultCallback; - pProbeResultCallbackUserdata = m_HostProbeInformation.m_pProbeResultCallbackUserdata; - } - if (fnProbeResultCallback) { - fnProbeResultCallback(this, (pService->m_pcName ?: m_pcHostname), pService, true, pProbeResultCallbackUserdata); +// Functional Update + if (pService->m_ProbeInformation.m_fnServiceProbeResultCallback) { + pService->m_ProbeInformation.m_fnServiceProbeResultCallback(pService->m_pcName, pService, true); } - // Prepare to announce service pService->m_ProbeInformation.m_u8SentCount = 0; pService->m_ProbeInformation.m_Timeout.reset(MDNS_ANNOUNCE_DELAY); @@ -1287,10 +1276,10 @@ bool MDNSResponder::_cancelProbingForHost(void) { bool bResult = false; m_HostProbeInformation.clear(false); - +// Functional // Send host notification - if (m_HostProbeInformation.m_fnProbeResultCallback) { - m_HostProbeInformation.m_fnProbeResultCallback(this, m_pcHostname, 0, false, m_HostProbeInformation.m_pProbeResultCallbackUserdata); + if (m_HostProbeInformation.m_fnHostProbeResultCallback) { + m_HostProbeInformation.m_fnHostProbeResultCallback(m_pcHostname, false); bResult = true; } @@ -1309,21 +1298,11 @@ bool MDNSResponder::_cancelProbingForService(stcMDNSService& p_rService) { bool bResult = false; p_rService.m_ProbeInformation.clear(false); - +// Functional // Send notification - MDNSProbeResultCallbackFn fnProbeResultCallback = 0; - void* pProbeResultCallbackUserdata = 0; - if (p_rService.m_ProbeInformation.m_fnProbeResultCallback) { - fnProbeResultCallback = p_rService.m_ProbeInformation.m_fnProbeResultCallback; - pProbeResultCallbackUserdata = p_rService.m_ProbeInformation.m_pProbeResultCallbackUserdata; - } - else { - fnProbeResultCallback = m_HostProbeInformation.m_fnProbeResultCallback; - pProbeResultCallbackUserdata = m_HostProbeInformation.m_pProbeResultCallbackUserdata; - } - if (fnProbeResultCallback) { - fnProbeResultCallback(this, (p_rService.m_pcName ?: m_pcHostname), &p_rService, false, pProbeResultCallbackUserdata); - bResult = true; + if (p_rService.m_ProbeInformation.m_fnServiceProbeResultCallback) { + p_rService.m_ProbeInformation.m_fnServiceProbeResultCallback(p_rService.m_pcName,&p_rService,false); + bResult = true; } return bResult; } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp index e41e4a08ba..7bf3cc0235 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp @@ -1162,7 +1162,9 @@ MDNSResponder::stcProbeInformation::stcProbeInformation(void) m_Timeout(std::numeric_limits::max()), m_bConflict(false), m_bTiebreakNeeded(false), - m_fnProbeResultCallback(0), +// Functional + m_fnHostProbeResultCallback(0), + m_fnServiceProbeResultCallback(0), m_pProbeResultCallbackUserdata(0) { } @@ -1176,8 +1178,10 @@ bool MDNSResponder::stcProbeInformation::clear(bool p_bClearUserdata /*= false*/ m_Timeout.reset(std::numeric_limits::max()); m_bConflict = false; m_bTiebreakNeeded = false; +// Functional if (p_bClearUserdata) { - m_fnProbeResultCallback = 0; + m_fnHostProbeResultCallback = 0; + m_fnServiceProbeResultCallback = 0; m_pProbeResultCallbackUserdata = 0; } return true; From 57c9ba49e23ae355ce5cff5647bdba5c4431b5cc Mon Sep 17 00:00:00 2001 From: hreintke Date: Wed, 23 Jan 2019 14:56:31 +0100 Subject: [PATCH 02/24] Fix ServiceMonitor.ino warnings --- .../LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 981cb0f4d5..26305114ee 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -95,7 +95,7 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder, bool p_bSetContent, // true: Component set, false: component deleted void* p_pUserdata) { // pUserdata; here '0', as none set via 'installServiceQuery' (void) p_pUserdata; - Serial.printf("MDNSServiceQueryCallback %8d\n",millis()); + Serial.printf("MDNSServiceQueryCallback\n"); if ((p_pMDNSResponder) && (hMDNSServiceQuery == p_hServiceQuery)) { @@ -188,8 +188,9 @@ bool serviceProbeResult (String p_pcServiceName, const MDNSResponder::hMDNSService p_hMDNSService, bool p_bProbeResult) { - Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); - + (void) p_hMDNSService; + Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); + return true; } From 168de7323e684165f20ff387b7ec9f69732c529f Mon Sep 17 00:00:00 2001 From: hreintke Date: Wed, 23 Jan 2019 17:56:02 +0100 Subject: [PATCH 03/24] Adding MDNSServiceQueryCallback functional ServiceMonitor.ino needs some updates for web page but works on Serial output. --- .../mDNS_ServiceMonitor.ino | 41 ++++++++++++++++--- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 6 +-- libraries/ESP8266mDNS/src/LEAmDNS.h | 24 +++++++---- libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp | 31 +++++++++----- 4 files changed, 75 insertions(+), 27 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 26305114ee..56732ee4b3 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -88,7 +88,36 @@ bool setStationHostname(const char* p_pcHostname) { /* MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder, // The MDNS responder object + +bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) +{ + String answerInfo; + switch (p_u32ServiceQueryAnswerMask){ + case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : + answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); + break; + case MDNSResponder::MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : + answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); + break; + case MDNSResponder::MDNSResponder::MDNSResponder::ServiceQueryAnswerType_IP4Address : + answerInfo = "IP4Address "; + for (IPAddress ip : serviceInfo.IPAdresses()){ + answerInfo += "- " + ip.toString(); + }; + break; + case MDNSResponder::MDNSResponder::MDNSResponder::ServiceQueryAnswerType_Txts : + answerInfo = "TXT " + serviceInfo.txtValue(); + + break; + default : + answerInfo = "Unknown"; + } + Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); + + return true; +} + +bool MDNSServiceQueryCallback1(MDNSResponder* p_pMDNSResponder, // The MDNS responder object const MDNSResponder::hMDNSServiceQuery p_hServiceQuery, // Handle to the service query uint32_t p_u32AnswerIndex, // Index of the updated answer uint32_t p_u32ServiceQueryAnswerMask, // Mask for the updated component @@ -188,9 +217,9 @@ bool serviceProbeResult (String p_pcServiceName, const MDNSResponder::hMDNSService p_hMDNSService, bool p_bProbeResult) { - (void) p_hMDNSService; - Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); - return true; + (void) p_hMDNSService; + Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); + return true; } @@ -233,7 +262,7 @@ bool hostProbeResult (String p_pcDomainName, bool p_bProbeResult) { // Install dynamic 'http.tcp' service query if (!hMDNSServiceQuery) { - hMDNSServiceQuery = MDNS.installServiceQuery("http", "tcp", MDNSServiceQueryCallback, 0); + hMDNSServiceQuery = MDNS.installServiceQuery("http", "tcp", MDNSServiceQueryCallback); if (hMDNSServiceQuery) { Serial.printf("MDNSProbeResultCallback: Service query for 'http.tcp' services installed.\n"); } else { @@ -309,7 +338,7 @@ void setup(void) { // Init the (currently empty) host domain string with 'esp8266' if ((!MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || (!MDNS.begin(pcHostDomain))) { - Serial.println("Error setting up MDNS responder!"); + Serial.println(" Error setting up MDNS responder!"); while (1) { // STOP delay(1000); } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index 9d4ff6a84e..37d658923d 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -759,10 +759,10 @@ uint16_t MDNSResponder::port(const uint32_t p_u32AnswerIndex) { * - answerTxts * */ +//Functional MDNSResponder::hMDNSServiceQuery MDNSResponder::installServiceQuery(const char* p_pcService, const char* p_pcProtocol, - MDNSResponder::MDNSServiceQueryCallbackFn p_fnCallback, - void* p_pUserdata) { + MDNSResponder::MDNSServiceQueryCallbackFunc p_fnCallback) { hMDNSServiceQuery hResult = 0; stcMDNSServiceQuery* pServiceQuery = 0; @@ -775,7 +775,7 @@ MDNSResponder::hMDNSServiceQuery MDNSResponder::installServiceQuery(const char* (_buildDomainForService(p_pcService, p_pcProtocol, pServiceQuery->m_ServiceTypeDomain))) { pServiceQuery->m_fnCallback = p_fnCallback; - pServiceQuery->m_pUserdata = p_pUserdata; + pServiceQuery->m_pUserdata = 0; pServiceQuery->m_bLegacyQuery = false; if (_sendMDNSServiceQuery(*pServiceQuery)) { diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 684f439640..0420f2a979 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -359,12 +359,21 @@ class MDNSResponder { * MDNSServiceQueryCallbackFn * Callback function for received answers for dynamic service queries */ +/* typedef bool (*MDNSServiceQueryCallbackFn)(MDNSResponder* p_pMDNSResponder, const hMDNSServiceQuery p_hServiceQuery, // dynamic service query handle uint32_t p_u32AnswerIndex, // index of the updated answer uint32_t p_u32ServiceQueryAnswerMask, // flag for the updated answer item bool p_bSetContent, // true: Answer component set, false: component deleted - void* p_pUserdata); // pUserdata set via 'installServiceQuery' + + void* p_pUserdata); // pUserdata set via 'installServiceQuery' +*/ +// Functional + struct MDNSServiceInfo; // forward declaration + typedef std::function MDNSServiceQueryCallbackFunc; // Install a dynamic service query. For every received answer (part) the given callback // function is called. The query will be updated every time, the TTL for an answer @@ -379,8 +388,7 @@ class MDNSResponder { // - hasAnswerTxts/answerTxts hMDNSServiceQuery installServiceQuery(const char* p_pcService, const char* p_pcProtocol, - MDNSServiceQueryCallbackFn p_fnCallback, - void* p_pUserdata); + MDNSServiceQueryCallbackFunc p_fnCallback); // Remove a dynamic service query bool removeServiceQuery(hMDNSServiceQuery p_hServiceQuery); @@ -468,6 +476,7 @@ class MDNSResponder { /** * MDNSServiceInfo, used in application callbacks */ +public: struct MDNSServiceInfo { MDNSServiceInfo(MDNSResponder* p_pM,MDNSResponder::hMDNSServiceQuery p_hS,uint32_t p_u32A) @@ -478,10 +487,10 @@ class MDNSResponder { MDNSResponder* p_pMDNSResponder; MDNSResponder::hMDNSServiceQuery p_hServiceQuery; uint32_t p_u32AnswerIndex; - const char* serviceDomain(){ + String serviceDomain(){ return p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex); }; - const char* hostDomain(){ + String hostDomain(){ return (p_pMDNSResponder->hasAnswerHostDomain(p_hServiceQuery, p_u32AnswerIndex)) ? p_pMDNSResponder->answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : 0; }; @@ -498,11 +507,12 @@ class MDNSResponder { } return internalIP; }; - const char* txtValue (){ + String txtValue (){ return (p_pMDNSResponder->hasAnswerTxts(p_hServiceQuery, p_u32AnswerIndex)) ? p_pMDNSResponder->answerTxts(p_hServiceQuery, p_u32AnswerIndex) : 0; }; }; +protected: /** * stcMDNSServiceTxt */ @@ -1000,7 +1010,7 @@ class MDNSResponder { stcMDNSServiceQuery* m_pNext; stcMDNS_RRDomain m_ServiceTypeDomain; // eg. _http._tcp.local - MDNSServiceQueryCallbackFn m_fnCallback; + MDNSServiceQueryCallbackFunc m_fnCallback; void* m_pUserdata; bool m_bLegacyQuery; uint8_t m_u8SentCount; diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp index b17b468f7e..7660fc33d1 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp @@ -776,10 +776,11 @@ bool MDNSResponder::_processPTRAnswer(const MDNSResponder::stcMDNS_RRAnswerPTR* pSQAnswer->releaseServiceDomain(); bResult = pServiceQuery->addAnswer(pSQAnswer); - + //Functional p_rbFoundNewKeyAnswer = true; if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), ServiceQueryAnswerType_ServiceDomain, true, pServiceQuery->m_pUserdata); + MDNSServiceInfo serviceInfo(this,(hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_ServiceDomain, true); } } } @@ -823,7 +824,8 @@ bool MDNSResponder::_processSRVAnswer(const MDNSResponder::stcMDNS_RRAnswerSRV* p_rbFoundNewKeyAnswer = true; if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), ServiceQueryAnswerType_HostDomainAndPort, true, pServiceQuery->m_pUserdata); + MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_HostDomainAndPort, true); } } } @@ -870,7 +872,8 @@ bool MDNSResponder::_processTXTAnswer(const MDNSResponder::stcMDNS_RRAnswerTXT* pSQAnswer->releaseTxts(); if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), ServiceQueryAnswerType_Txts, true, pServiceQuery->m_pUserdata); + MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo , ServiceQueryAnswerType_Txts, true); } } } @@ -933,9 +936,10 @@ bool MDNSResponder::_processTXTAnswer(const MDNSResponder::stcMDNS_RRAnswerTXT* (pSQAnswer->addIP4Address(pIP4Address))) { pSQAnswer->m_u32ContentFlags |= ServiceQueryAnswerType_IP4Address; - +// Functional if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), ServiceQueryAnswerType_IP4Address, true, pServiceQuery->m_pUserdata); + MDNSServiceInfo serviceInfo (this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_IP4Address, true); } } else { @@ -1485,7 +1489,8 @@ bool MDNSResponder::_checkServiceQueryCache(void) { else { // Timed out! -> Delete if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), ServiceQueryAnswerType_ServiceDomain, false, pServiceQuery->m_pUserdata); + MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_ServiceDomain, false); } DEBUG_EX_INFO( DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _checkServiceQueryCache: Will remove PTR answer for ")); @@ -1542,9 +1547,10 @@ bool MDNSResponder::_checkServiceQueryCache(void) { // Remove content flags for deleted answer parts pSQAnswer->m_u32ContentFlags &= ~u32ContentFlags; - +//Functional if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), u32ContentFlags, false, pServiceQuery->m_pUserdata); + MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo, u32ContentFlags, false); } } } // HostDomainAndPort flagged @@ -1580,7 +1586,8 @@ bool MDNSResponder::_checkServiceQueryCache(void) { pSQAnswer->m_u32ContentFlags &= ~ServiceQueryAnswerType_Txts; if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), ServiceQueryAnswerType_Txts, false, pServiceQuery->m_pUserdata); + MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_Txts, false); } } } // TXTs flagged @@ -1627,7 +1634,9 @@ bool MDNSResponder::_checkServiceQueryCache(void) { } // Notify client if (pServiceQuery->m_fnCallback) { - pServiceQuery->m_fnCallback(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer), ServiceQueryAnswerType_IP4Address, false, pServiceQuery->m_pUserdata); +// Functional + MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_IP4Address, false); } } } // IP4 flagged From ab868596e436ae8dc8b3a2926e326ed03fa119e5 Mon Sep 17 00:00:00 2001 From: hreintke Date: Thu, 24 Jan 2019 13:08:58 +0100 Subject: [PATCH 04/24] DynamicServices Functional --- .../LEAmDNS/mDNS_Clock/mDNS_Clock.ino | 50 ++++++---------- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 8 +-- libraries/ESP8266mDNS/src/LEAmDNS.h | 59 ++++++++++++++----- libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp | 4 +- 4 files changed, 65 insertions(+), 56 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino index 660271b70b..037a2b3dd6 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino @@ -65,9 +65,6 @@ #define STAPSK "your-password" #endif -const char* ssid = STASSID; -const char* password = STAPSK; - char* pcHostDomain = 0; // Negociated host domain bool bHostDomainConfirmed = false; // Flags the confirmation of the host domain MDNSResponder::hMDNSService hMDNSService = 0; // The handle of the clock service in the MDNS responder @@ -135,16 +132,12 @@ bool setStationHostname(const char* p_pcHostname) { This can be triggered by calling MDNS.announce(). */ -bool MDNSDynamicServiceTxtCallback(MDNSResponder* p_pMDNSResponder, - const MDNSResponder::hMDNSService p_hService, - void* p_pUserdata) { +bool MDNSDynamicServiceTxtCallback(const MDNSResponder::hMDNSService p_hService) { Serial.println("MDNSDynamicServiceTxtCallback"); - (void) p_pUserdata; - if ((p_pMDNSResponder) && - (hMDNSService == p_hService)) { + if (hMDNSService == p_hService) { Serial.printf("Updating curtime TXT item to: %s\n", getTimeString()); - p_pMDNSResponder->addDynamicServiceTxt(p_hService, "curtime", getTimeString()); + MDNS.addDynamicServiceTxt(p_hService, "curtime", getTimeString()); } return true; } @@ -160,17 +153,10 @@ bool MDNSDynamicServiceTxtCallback(MDNSResponder* p_pMDNSResponder, restarted via p_pMDNSResponder->setHostname(). */ -bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder, - const char* p_pcDomainName, - const MDNSResponder::hMDNSService p_hService, - bool p_bProbeResult, - void* p_pUserdata) { - Serial.println("MDNSProbeResultCallback"); - (void) p_pUserdata; +bool hostProbeResult (String p_pcDomainName, bool p_bProbeResult) { - if ((p_pMDNSResponder) && - (0 == p_hService)) { // Called for host domain - Serial.printf("MDNSProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName, (p_bProbeResult ? "free" : "already USED!")); + Serial.println("MDNSProbeResultCallback"); + Serial.printf("MDNSProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); if (true == p_bProbeResult) { // Set station hostname setStationHostname(pcHostDomain); @@ -181,24 +167,23 @@ bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder, if (!hMDNSService) { // Add a 'clock.tcp' service to port 'SERVICE_PORT', using the host domain as instance domain - hMDNSService = p_pMDNSResponder->addService(0, "espclk", "tcp", SERVICE_PORT); + hMDNSService = MDNS.addService(0, "espclk", "tcp", SERVICE_PORT); if (hMDNSService) { // Add a simple static MDNS service TXT item - p_pMDNSResponder->addServiceTxt(hMDNSService, "port#", SERVICE_PORT); + MDNS.addServiceTxt(hMDNSService, "port#", SERVICE_PORT); // Set the callback function for dynamic service TXTs - p_pMDNSResponder->setDynamicServiceTxtCallback(hMDNSService, MDNSDynamicServiceTxtCallback, 0); + MDNS.setDynamicServiceTxtCallback(MDNSDynamicServiceTxtCallback); } } } } else { - // Change hostname, use '-' as divider between base name and index - if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { - p_pMDNSResponder->setHostname(pcHostDomain); - } else { - Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); + // Change hostname, use '-' as divider between base name and index + if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { + MDNS.setHostname(pcHostDomain); + } else { + Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); + } } - } - } return true; } @@ -285,7 +270,7 @@ void setup(void) { setClock(); // Setup MDNS responder - MDNS.setProbeResultCallback(MDNSProbeResultCallback, 0); + MDNS.setHostProbeResultCallback(hostProbeResult); // Init the (currently empty) host domain string with 'esp8266' if ((!MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || (!MDNS.begin(pcHostDomain))) { @@ -316,8 +301,9 @@ void loop(void) { MDNS.update(); // Update time (if needed) + //static unsigned long ulNextTimeUpdate = UPDATE_CYCLE; static esp8266::polledTimeout::periodic timeout(UPDATE_CYCLE); - if (timeout.expired()) { + if (timeout.expired()){ if (hMDNSService) { // Just trigger a new MDNS announcement, this will lead to a call to diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index 37d658923d..1655c7da6b 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -459,11 +459,9 @@ bool MDNSResponder::addServiceTxt(String p_strService, * service TXT items are needed. * */ -bool MDNSResponder::setDynamicServiceTxtCallback(MDNSResponder::MDNSDynamicServiceTxtCallbackFn p_fnCallback, - void* p_pUserdata) { +bool MDNSResponder::setDynamicServiceTxtCallback(MDNSResponder::MDNSDynamicServiceTxtCallbackFunc p_fnCallback) { m_fnServiceTxtCallback = p_fnCallback; - m_pServiceTxtCallbackUserdata = p_pUserdata; return true; } @@ -476,15 +474,13 @@ bool MDNSResponder::setDynamicServiceTxtCallback(MDNSResponder::MDNSDynamicServi * */ bool MDNSResponder::setDynamicServiceTxtCallback(MDNSResponder::hMDNSService p_hService, - MDNSResponder::MDNSDynamicServiceTxtCallbackFn p_fnCallback, - void* p_pUserdata) { + MDNSResponder::MDNSDynamicServiceTxtCallbackFunc p_fnCallback) { bool bResult = false; stcMDNSService* pService = _findService(p_hService); if (pService) { pService->m_fnTxtCallback = p_fnCallback; - pService->m_pTxtCallbackUserdata = p_pUserdata; bResult = true; } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 0420f2a979..8be866d0b7 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -109,6 +109,8 @@ #include "include/UdpContext.h" #include #include +#include + #include "ESP8266WiFi.h" @@ -275,19 +277,20 @@ class MDNSResponder { * MDNSDynamicServiceTxtCallbackFn * Callback function for dynamic MDNS TXT items */ - typedef bool (*MDNSDynamicServiceTxtCallbackFn)(MDNSResponder* p_pMDNSResponder, - const hMDNSService p_hService, - void* p_pUserdata); +// Functional +// typedef bool (*MDNSDynamicServiceTxtCallbackFn)(MDNSResponder* p_pMDNSResponder, +// const hMDNSService p_hService, +// void* p_pUserdata); + + typedef std::function MDNSDynamicServiceTxtCallbackFunc; // Set a global callback for dynamic MDNS TXT items. The callback function is called // every time, a TXT item is needed for one of the installed services. - bool setDynamicServiceTxtCallback(MDNSDynamicServiceTxtCallbackFn p_fnCallback, - void* p_pUserdata); + bool setDynamicServiceTxtCallback(MDNSDynamicServiceTxtCallbackFunc p_fnCallback); // Set a service specific callback for dynamic MDNS TXT items. The callback function // is called every time, a TXT item is needed for the given service. bool setDynamicServiceTxtCallback(const hMDNSService p_hService, - MDNSDynamicServiceTxtCallbackFn p_fnCallback, - void* p_pUserdata); + MDNSDynamicServiceTxtCallbackFunc p_fnCallback); // Add a (dynamic) MDNS TXT item ('key' = 'value') to the service // Dynamic TXT items are removed right after one-time use. So they need to be added @@ -490,27 +493,51 @@ class MDNSResponder { String serviceDomain(){ return p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex); }; + bool hostDomainAvailable() + { + return (p_pMDNSResponder->hasAnswerHostDomain(p_hServiceQuery, p_u32AnswerIndex)); + } String hostDomain(){ - return (p_pMDNSResponder->hasAnswerHostDomain(p_hServiceQuery, p_u32AnswerIndex)) ? - p_pMDNSResponder->answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : 0; + return (hostDomainAvailable()) ? + p_pMDNSResponder->answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : String(); }; + bool hostPortAvailable() + { + return (p_pMDNSResponder->hasAnswerPort(p_hServiceQuery, p_u32AnswerIndex)); + } uint16_t hostPort(){ - return (p_pMDNSResponder->hasAnswerPort(p_hServiceQuery, p_u32AnswerIndex)) ? + return (hostPortAvailable()) ? p_pMDNSResponder->answerPort(p_hServiceQuery, p_u32AnswerIndex) : 0; }; + bool IPAddressAvailable() + { + return (p_pMDNSResponder->hasAnswerIP4Address(p_hServiceQuery,p_u32AnswerIndex )); + } std::vector IPAdresses(){ std::vector internalIP; - if (p_pMDNSResponder->hasAnswerIP4Address(p_hServiceQuery,p_u32AnswerIndex )) { + if (IPAddressAvailable()) { for (uint32_t u2 = 0; u2 < p_pMDNSResponder->answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u2) { internalIP.push_back(p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u2)); } } return internalIP; }; - String txtValue (){ - return (p_pMDNSResponder->hasAnswerTxts(p_hServiceQuery, p_u32AnswerIndex)) ? - p_pMDNSResponder->answerTxts(p_hServiceQuery, p_u32AnswerIndex) : 0; + bool txtAvailable() + { + return (p_pMDNSResponder->hasAnswerTxts(p_hServiceQuery, p_u32AnswerIndex)); + } + String strKeyValue (){ + return (txtAvailable()) ? + p_pMDNSResponder->answerTxts(p_hServiceQuery, p_u32AnswerIndex) : String(); }; + std::map keyValues() + { + return std::map(); + } + String value(String key) + { + return String(); + } }; protected: /** @@ -866,7 +893,7 @@ class MDNSResponder { uint16_t m_u16Port; uint8_t m_u8ReplyMask; stcMDNSServiceTxts m_Txts; - MDNSDynamicServiceTxtCallbackFn m_fnTxtCallback; + MDNSDynamicServiceTxtCallbackFunc m_fnTxtCallback; void* m_pTxtCallbackUserdata; stcProbeInformation m_ProbeInformation; @@ -1088,7 +1115,7 @@ class MDNSResponder { stcMDNSServiceQuery* m_pServiceQueries; WiFiEventHandler m_DisconnectedHandler; WiFiEventHandler m_GotIPHandler; - MDNSDynamicServiceTxtCallbackFn m_fnServiceTxtCallback; + MDNSDynamicServiceTxtCallbackFunc m_fnServiceTxtCallback; void* m_pServiceTxtCallbackUserdata; bool m_bPassivModeEnabled; stcProbeInformation m_HostProbeInformation; diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp index f8042ff185..ce7512d9a9 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp @@ -635,12 +635,12 @@ MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_addServiceTxt(MDNSResponder::s bool MDNSResponder::_collectServiceTxts(MDNSResponder::stcMDNSService& p_rService) { bool bResult = (m_fnServiceTxtCallback - ? m_fnServiceTxtCallback(this, (hMDNSService)&p_rService, m_pServiceTxtCallbackUserdata) + ? m_fnServiceTxtCallback((hMDNSService)&p_rService) : true); if ((bResult) && (p_rService.m_fnTxtCallback)) { - bResult = p_rService.m_fnTxtCallback(this, (hMDNSService)&p_rService, p_rService.m_pTxtCallbackUserdata); + bResult = p_rService.m_fnTxtCallback((hMDNSService)&p_rService); } return bResult; } From 8f8e90fb60ecb588b38ab659f85dc70ad29885f8 Mon Sep 17 00:00:00 2001 From: hreintke Date: Thu, 24 Jan 2019 13:38:25 +0100 Subject: [PATCH 05/24] Fix ServiceMonitor to match latest MDNSServiceInfo --- .../LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 56732ee4b3..409204778b 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -96,17 +96,17 @@ bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint3 case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); break; - case MDNSResponder::MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : + case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); break; - case MDNSResponder::MDNSResponder::MDNSResponder::ServiceQueryAnswerType_IP4Address : + case MDNSResponder::ServiceQueryAnswerType_IP4Address : answerInfo = "IP4Address "; for (IPAddress ip : serviceInfo.IPAdresses()){ answerInfo += "- " + ip.toString(); }; break; - case MDNSResponder::MDNSResponder::MDNSResponder::ServiceQueryAnswerType_Txts : - answerInfo = "TXT " + serviceInfo.txtValue(); + case MDNSResponder::ServiceQueryAnswerType_Txts : + answerInfo = "TXT " + serviceInfo.strKeyValue(); break; default : From e3dee4fefa22d0827507e35baf2b74be090ea143 Mon Sep 17 00:00:00 2001 From: hreintke Date: Thu, 24 Jan 2019 14:58:53 +0100 Subject: [PATCH 06/24] Fix unused variable in LEAdns.h --- libraries/ESP8266mDNS/src/LEAmDNS.h | 1 + 1 file changed, 1 insertion(+) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 8be866d0b7..73713bbd41 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -536,6 +536,7 @@ class MDNSResponder { } String value(String key) { + (void) key; return String(); } }; From b23716094cb038e390253f691d6605804879105f Mon Sep 17 00:00:00 2001 From: hreintke Date: Thu, 24 Jan 2019 16:43:16 +0100 Subject: [PATCH 07/24] mDNS_Clock.ino fix --- .../ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino index 037a2b3dd6..9050850e0c 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino @@ -65,6 +65,9 @@ #define STAPSK "your-password" #endif +const char* ssid = STASSID; +const char* password = STAPSK; + char* pcHostDomain = 0; // Negociated host domain bool bHostDomainConfirmed = false; // Flags the confirmation of the host domain MDNSResponder::hMDNSService hMDNSService = 0; // The handle of the clock service in the MDNS responder From 6bb6e90a2b7f9c6001449f0a19b0d2b7dccd5b75 Mon Sep 17 00:00:00 2001 From: david gauchard Date: Thu, 24 Jan 2019 21:22:56 +0100 Subject: [PATCH 08/24] example restyle --- .../LEAmDNS/mDNS_Clock/mDNS_Clock.ino | 54 +++---- .../mDNS_ServiceMonitor.ino | 144 +++++++++--------- 2 files changed, 98 insertions(+), 100 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino index 9050850e0c..75a04b22c4 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino @@ -156,37 +156,37 @@ bool MDNSDynamicServiceTxtCallback(const MDNSResponder::hMDNSService p_hService) restarted via p_pMDNSResponder->setHostname(). */ -bool hostProbeResult (String p_pcDomainName, bool p_bProbeResult) { +bool hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { Serial.println("MDNSProbeResultCallback"); - Serial.printf("MDNSProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); - if (true == p_bProbeResult) { - // Set station hostname - setStationHostname(pcHostDomain); - - if (!bHostDomainConfirmed) { - // Hostname free -> setup clock service - bHostDomainConfirmed = true; - - if (!hMDNSService) { - // Add a 'clock.tcp' service to port 'SERVICE_PORT', using the host domain as instance domain - hMDNSService = MDNS.addService(0, "espclk", "tcp", SERVICE_PORT); - if (hMDNSService) { - // Add a simple static MDNS service TXT item - MDNS.addServiceTxt(hMDNSService, "port#", SERVICE_PORT); - // Set the callback function for dynamic service TXTs - MDNS.setDynamicServiceTxtCallback(MDNSDynamicServiceTxtCallback); - } + Serial.printf("MDNSProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); + if (true == p_bProbeResult) { + // Set station hostname + setStationHostname(pcHostDomain); + + if (!bHostDomainConfirmed) { + // Hostname free -> setup clock service + bHostDomainConfirmed = true; + + if (!hMDNSService) { + // Add a 'clock.tcp' service to port 'SERVICE_PORT', using the host domain as instance domain + hMDNSService = MDNS.addService(0, "espclk", "tcp", SERVICE_PORT); + if (hMDNSService) { + // Add a simple static MDNS service TXT item + MDNS.addServiceTxt(hMDNSService, "port#", SERVICE_PORT); + // Set the callback function for dynamic service TXTs + MDNS.setDynamicServiceTxtCallback(MDNSDynamicServiceTxtCallback); } } + } + } else { + // Change hostname, use '-' as divider between base name and index + if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { + MDNS.setHostname(pcHostDomain); } else { - // Change hostname, use '-' as divider between base name and index - if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { - MDNS.setHostname(pcHostDomain); - } else { - Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); - } - } + Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); + } + } return true; } @@ -306,7 +306,7 @@ void loop(void) { // Update time (if needed) //static unsigned long ulNextTimeUpdate = UPDATE_CYCLE; static esp8266::polledTimeout::periodic timeout(UPDATE_CYCLE); - if (timeout.expired()){ + if (timeout.expired()) { if (hMDNSService) { // Just trigger a new MDNS announcement, this will lead to a call to diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 409204778b..a70cf3b277 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -89,40 +89,39 @@ bool setStationHostname(const char* p_pcHostname) { MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) -{ - String answerInfo; - switch (p_u32ServiceQueryAnswerMask){ - case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : - answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); - break; - case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : - answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); - break; - case MDNSResponder::ServiceQueryAnswerType_IP4Address : - answerInfo = "IP4Address "; - for (IPAddress ip : serviceInfo.IPAdresses()){ - answerInfo += "- " + ip.toString(); - }; - break; - case MDNSResponder::ServiceQueryAnswerType_Txts : - answerInfo = "TXT " + serviceInfo.strKeyValue(); - - break; - default : - answerInfo = "Unknown"; - } - Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); - - return true; +bool MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) { + String answerInfo; + switch (p_u32ServiceQueryAnswerMask) { + case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : + answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); + break; + case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : + answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); + break; + case MDNSResponder::ServiceQueryAnswerType_IP4Address : + answerInfo = "IP4Address "; + for (IPAddress ip : serviceInfo.IPAdresses()) { + answerInfo += "- " + ip.toString(); + }; + break; + case MDNSResponder::ServiceQueryAnswerType_Txts : + answerInfo = "TXT " + serviceInfo.strKeyValue(); + + break; + default : + answerInfo = "Unknown"; + } + Serial.printf("Answer %s %s\n", answerInfo.c_str(), p_bSetContent ? "Modified" : "Deleted"); + + return true; } bool MDNSServiceQueryCallback1(MDNSResponder* p_pMDNSResponder, // The MDNS responder object - const MDNSResponder::hMDNSServiceQuery p_hServiceQuery, // Handle to the service query - uint32_t p_u32AnswerIndex, // Index of the updated answer - uint32_t p_u32ServiceQueryAnswerMask, // Mask for the updated component - bool p_bSetContent, // true: Component set, false: component deleted - void* p_pUserdata) { // pUserdata; here '0', as none set via 'installServiceQuery' + const MDNSResponder::hMDNSServiceQuery p_hServiceQuery, // Handle to the service query + uint32_t p_u32AnswerIndex, // Index of the updated answer + uint32_t p_u32ServiceQueryAnswerMask, // Mask for the updated component + bool p_bSetContent, // true: Component set, false: component deleted + void* p_pUserdata) { // pUserdata; here '0', as none set via 'installServiceQuery' (void) p_pUserdata; Serial.printf("MDNSServiceQueryCallback\n"); @@ -213,13 +212,12 @@ bool MDNSServiceQueryCallback1(MDNSResponder* p_pMDNSResponder, Probe result callback for Services */ -bool serviceProbeResult (String p_pcServiceName, - const MDNSResponder::hMDNSService p_hMDNSService, - bool p_bProbeResult) -{ - (void) p_hMDNSService; - Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); - return true; +bool serviceProbeResult(String p_pcServiceName, + const MDNSResponder::hMDNSService p_hMDNSService, + bool p_bProbeResult) { + (void) p_hMDNSService; + Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); + return true; } @@ -235,50 +233,50 @@ bool serviceProbeResult (String p_pcServiceName, */ -bool hostProbeResult (String p_pcDomainName, bool p_bProbeResult) { +bool hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { - Serial.printf("MDNSHostProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); + Serial.printf("MDNSHostProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); - if (true == p_bProbeResult) { - // Set station hostname - setStationHostname(pcHostDomain); + if (true == p_bProbeResult) { + // Set station hostname + setStationHostname(pcHostDomain); - if (!bHostDomainConfirmed) { - // Hostname free -> setup clock service - bHostDomainConfirmed = true; + if (!bHostDomainConfirmed) { + // Hostname free -> setup clock service + bHostDomainConfirmed = true; - if (!hMDNSService) { - // Add a 'http.tcp' service to port 'SERVICE_PORT', using the host domain as instance domain - hMDNSService = MDNS.addService(0, "http", "tcp", SERVICE_PORT); - if (hMDNSService) { - MDNS.setServiceProbeResultCallback(hMDNSService, serviceProbeResult); + if (!hMDNSService) { + // Add a 'http.tcp' service to port 'SERVICE_PORT', using the host domain as instance domain + hMDNSService = MDNS.addService(0, "http", "tcp", SERVICE_PORT); + if (hMDNSService) { + MDNS.setServiceProbeResultCallback(hMDNSService, serviceProbeResult); - // Add some '_http._tcp' protocol specific MDNS service TXT items - // See: http://www.dns-sd.org/txtrecords.html#http - MDNS.addServiceTxt(hMDNSService, "user", ""); - MDNS.addServiceTxt(hMDNSService, "password", ""); - MDNS.addServiceTxt(hMDNSService, "path", "/"); - } + // Add some '_http._tcp' protocol specific MDNS service TXT items + // See: http://www.dns-sd.org/txtrecords.html#http + MDNS.addServiceTxt(hMDNSService, "user", ""); + MDNS.addServiceTxt(hMDNSService, "password", ""); + MDNS.addServiceTxt(hMDNSService, "path", "/"); + } - // Install dynamic 'http.tcp' service query - if (!hMDNSServiceQuery) { - hMDNSServiceQuery = MDNS.installServiceQuery("http", "tcp", MDNSServiceQueryCallback); - if (hMDNSServiceQuery) { - Serial.printf("MDNSProbeResultCallback: Service query for 'http.tcp' services installed.\n"); - } else { - Serial.printf("MDNSProbeResultCallback: FAILED to install service query for 'http.tcp' services!\n"); - } + // Install dynamic 'http.tcp' service query + if (!hMDNSServiceQuery) { + hMDNSServiceQuery = MDNS.installServiceQuery("http", "tcp", MDNSServiceQueryCallback); + if (hMDNSServiceQuery) { + Serial.printf("MDNSProbeResultCallback: Service query for 'http.tcp' services installed.\n"); + } else { + Serial.printf("MDNSProbeResultCallback: FAILED to install service query for 'http.tcp' services!\n"); } } } + } + } else { + // Change hostname, use '-' as divider between base name and index + if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { + MDNS.setHostname(pcHostDomain); } else { - // Change hostname, use '-' as divider between base name and index - if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { - MDNS.setHostname(pcHostDomain); - } else { - Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); - } - } + Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); + } + } return true; } @@ -302,7 +300,7 @@ void handleHTTPRequest() { Serial.println("Sending 200"); server.send(200, "text/html", s); Serial.println("Done with request"); - Serial.printf("FM %d\n",ESP.getFreeHeap()); + Serial.printf("FM %d\n", ESP.getFreeHeap()); } /* From 639f097cfba1db4a45d07a6f96fb61b2df27a178 Mon Sep 17 00:00:00 2001 From: hreintke Date: Sat, 26 Jan 2019 12:07:09 +0100 Subject: [PATCH 09/24] Add keyValues and answerInfo --- .../mDNS_ServiceMonitor.ino | 175 ++++++------------ libraries/ESP8266mDNS/src/LEAmDNS.cpp | 12 +- libraries/ESP8266mDNS/src/LEAmDNS.h | 26 ++- libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp | 8 + 4 files changed, 94 insertions(+), 127 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index a70cf3b277..ebeb178bc0 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -89,123 +89,37 @@ bool setStationHostname(const char* p_pcHostname) { MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) { - String answerInfo; - switch (p_u32ServiceQueryAnswerMask) { - case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : - answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); - break; - case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : - answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); - break; - case MDNSResponder::ServiceQueryAnswerType_IP4Address : - answerInfo = "IP4Address "; - for (IPAddress ip : serviceInfo.IPAdresses()) { - answerInfo += "- " + ip.toString(); - }; - break; - case MDNSResponder::ServiceQueryAnswerType_Txts : - answerInfo = "TXT " + serviceInfo.strKeyValue(); - - break; - default : - answerInfo = "Unknown"; - } - Serial.printf("Answer %s %s\n", answerInfo.c_str(), p_bSetContent ? "Modified" : "Deleted"); - - return true; +bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) +{ + String answerInfo; + switch (p_u32ServiceQueryAnswerMask){ + case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : + answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); + break; + case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : + answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); + break; + case MDNSResponder::ServiceQueryAnswerType_IP4Address : + answerInfo = "IP4Address "; + for (IPAddress ip : serviceInfo.IPAdresses()){ + answerInfo += "- " + ip.toString(); + }; + break; + case MDNSResponder::ServiceQueryAnswerType_Txts : + answerInfo = "TXT " + serviceInfo.strKeyValue(); + for (auto kv : serviceInfo.keyValues()) + { + answerInfo += "\nkv : " + kv.first + " : "+ kv.second; + } + break; + default : + answerInfo = "Unknown"; + } + Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); + + return true; } -bool MDNSServiceQueryCallback1(MDNSResponder* p_pMDNSResponder, // The MDNS responder object - const MDNSResponder::hMDNSServiceQuery p_hServiceQuery, // Handle to the service query - uint32_t p_u32AnswerIndex, // Index of the updated answer - uint32_t p_u32ServiceQueryAnswerMask, // Mask for the updated component - bool p_bSetContent, // true: Component set, false: component deleted - void* p_pUserdata) { // pUserdata; here '0', as none set via 'installServiceQuery' - (void) p_pUserdata; - Serial.printf("MDNSServiceQueryCallback\n"); - - if ((p_pMDNSResponder) && - (hMDNSServiceQuery == p_hServiceQuery)) { - - if (MDNSResponder::ServiceQueryAnswerType_ServiceDomain & p_u32ServiceQueryAnswerMask) { - Serial.printf("MDNSServiceQueryCallback: Service domain '%s' %s index %u\n", - p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex), - (p_bSetContent ? "added at" : "removed from"), - p_u32AnswerIndex); - } else if (MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort & p_u32ServiceQueryAnswerMask) { - if (p_bSetContent) { - Serial.printf("MDNSServiceQueryCallback: Host domain and port added/updated for service '%s': %s:%u\n", - p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex), - p_pMDNSResponder->answerHostDomain(p_hServiceQuery, p_u32AnswerIndex), - p_pMDNSResponder->answerPort(p_hServiceQuery, p_u32AnswerIndex)); - } else { - Serial.printf("MDNSServiceQueryCallback: Host domain and port removed from service '%s'\n", - p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); - } - } else if (MDNSResponder::ServiceQueryAnswerType_IP4Address & p_u32ServiceQueryAnswerMask) { - if (p_bSetContent) { - Serial.printf("MDNSServiceQueryCallback: IP4 address added/updated for service '%s': ", - p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); - for (uint32_t u = 0; u < p_pMDNSResponder->answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u) { - Serial.printf("- %s ", p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u).toString().c_str()); - } - Serial.printf("\n"); - } else { - Serial.printf("MDNSServiceQueryCallback: IP4 address removed from service '%s'\n", - p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); - } - } else if (MDNSResponder::ServiceQueryAnswerType_Txts & p_u32ServiceQueryAnswerMask) { - if (p_bSetContent) { - Serial.printf("MDNSServiceQueryCallback: TXT items added/updated for service '%s': %s\n", - p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex), - p_pMDNSResponder->answerTxts(p_hServiceQuery, p_u32AnswerIndex)); - } else { - Serial.printf("MDNSServiceQueryCallback: TXT items removed from service '%s'\n", - p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); - } - } - - // - // Create the current list of 'http.tcp' services - uint32_t u32Answers = p_pMDNSResponder->answerCount(p_hServiceQuery); - if (u32Answers) { - strHTTPServices = ""; - for (uint32_t u = 0; u < u32Answers; ++u) { - // Index and service domain - strHTTPServices += "
  • "; - strHTTPServices += p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, u); - // Host domain and port - if ((p_pMDNSResponder->hasAnswerHostDomain(p_hServiceQuery, u)) && - (p_pMDNSResponder->hasAnswerPort(p_hServiceQuery, u))) { - strHTTPServices += "
    Hostname: "; - strHTTPServices += p_pMDNSResponder->answerHostDomain(p_hServiceQuery, u); - strHTTPServices += ":"; - strHTTPServices += p_pMDNSResponder->answerPort(p_hServiceQuery, u); - } - // IP4 address - if (p_pMDNSResponder->hasAnswerIP4Address(p_hServiceQuery, u)) { - strHTTPServices += "
    IP4: "; - for (uint32_t u2 = 0; u2 < p_pMDNSResponder->answerIP4AddressCount(p_hServiceQuery, u); ++u2) { - if (0 != u2) { - strHTTPServices += ", "; - } - strHTTPServices += p_pMDNSResponder->answerIP4Address(p_hServiceQuery, u, u2).toString(); - } - } - // MDNS TXT items - if (p_pMDNSResponder->hasAnswerTxts(p_hServiceQuery, u)) { - strHTTPServices += "
    TXT: "; - strHTTPServices += p_pMDNSResponder->answerTxts(p_hServiceQuery, u); - } - strHTTPServices += "
    • "; - } - } else { - strHTTPServices = cstrNoHTTPServices; - } - } - return true; -} /* MDNSServiceProbeResultCallback @@ -289,18 +203,37 @@ void handleHTTPRequest() { Serial.println("HTTP Request"); IPAddress ip = WiFi.localIP(); - String ipStr = String(ip[0]) + '.' + String(ip[1]) + '.' + String(ip[2]) + '.' + String(ip[3]); + String ipStr = ip.toString(); String s = "\r\n

    Hello from "; - s += WiFi.hostname() + ".local at " + ipStr + "

    "; - s += "

    Local HTTP services are :

      "; - s += strHTTPServices; - // done :-) + s += WiFi.hostname() + ".local at " + WiFi.localIP().toString() + ""; + s += "

      Local HTTP services are :

      "; + s += "
        "; + for (auto info : MDNS.answerInfo(hMDNSServiceQuery)) { + s += "
      1. "; + s += info.serviceDomain(); + if (info.hostDomainAvailable()) { + s += "
        Hostname: "; + s += info.hostDomain() + (info.hostPortAvailable()) ? (":" + String(info.hostPort())) : ""; + } + if (info.IPAddressAvailable()) { + s += "
        IP4:"; + for (auto ip : info.IPAdresses()) { + s += " " + ip.toString(); + } + } + if (info.txtAvailable()) { + s += "
        TXT:
        "; + for (auto kv : info.keyValues()) { + s += "\t" + kv.first + " : " + kv.second + "
        "; + } + } + s += "
        2. "; + } s += "

      "; Serial.println("Sending 200"); server.send(200, "text/html", s); Serial.println("Done with request"); - Serial.printf("FM %d\n", ESP.getFreeHeap()); } /* diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index 1655c7da6b..f56085e09e 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -813,6 +813,15 @@ uint32_t MDNSResponder::answerCount(const MDNSResponder::hMDNSServiceQuery p_hSe return (pServiceQuery ? pServiceQuery->answerCount() : 0); } +std::vector MDNSResponder::answerInfo (const MDNSResponder::hMDNSServiceQuery p_hServiceQuery) { + std::vector tempVector; + for (int i=0;im_Txts.m_pTxts) && (!pSQAnswer->m_pcTxts)) { - + pSQAnswer->m_pcTxts = pSQAnswer->allocTxts(pSQAnswer->m_Txts.c_strLength()); if (pSQAnswer->m_pcTxts) { pSQAnswer->m_Txts.c_str(pSQAnswer->m_pcTxts); @@ -1011,7 +1020,6 @@ const char* MDNSResponder::answerTxts(const MDNSResponder::hMDNSServiceQuery p_h return (pSQAnswer ? pSQAnswer->m_pcTxts : 0); } - /* * PROBING */ diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 73713bbd41..48b4c545f6 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -396,6 +396,8 @@ class MDNSResponder { bool removeServiceQuery(hMDNSServiceQuery p_hServiceQuery); uint32_t answerCount(const hMDNSServiceQuery p_hServiceQuery); + std::vector answerInfo (const MDNSResponder::hMDNSServiceQuery p_hServiceQuery); + const char* answerServiceDomain(const hMDNSServiceQuery p_hServiceQuery, const uint32_t p_u32AnswerIndex); bool hasAnswerHostDomain(const hMDNSServiceQuery p_hServiceQuery, @@ -429,7 +431,7 @@ class MDNSResponder { // Get the TXT items as a ';'-separated string const char* answerTxts(const hMDNSServiceQuery p_hServiceQuery, const uint32_t p_u32AnswerIndex); - + /** * MDNSProbeResultCallbackFn * Callback function for (host and service domain) probe results @@ -532,15 +534,28 @@ class MDNSResponder { }; std::map keyValues() { - return std::map(); + std::map tempKV; + for (auto kv = p_pMDNSResponder->_answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex);kv != nullptr;kv = kv->m_pNext) { + tempKV.insert(std::pair(String(kv->m_pcKey),String(kv->m_pcValue))); + } + return tempKV; } String value(String key) { - (void) key; - return String(); + String result; + + for (stcMDNSServiceTxt* pTxt=p_pMDNSResponder->_answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex); pTxt; pTxt=pTxt->m_pNext) { + if ((key.c_str()) && + (0 == strcmp(pTxt->m_pcKey, key.c_str()))) { + result = String(pTxt->m_pcValue); + break; + } + } + return result; } }; protected: + /** * stcMDNSServiceTxt */ @@ -1352,6 +1367,9 @@ class MDNSResponder { const char* p_pcValue, bool p_bTemp); + stcMDNSServiceTxt* _answerKeyvalue(const hMDNSServiceQuery p_hServiceQuery, + const uint32_t p_u32AnswerIndex); + bool _collectServiceTxts(stcMDNSService& p_rService); bool _releaseTempServiceTxts(stcMDNSService& p_rService); const stcMDNSServiceTxt* _serviceTxts(const char* p_pcName, diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp index ce7512d9a9..ec37709d06 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp @@ -629,6 +629,14 @@ MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_addServiceTxt(MDNSResponder::s 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 */ From 5da1832fa991c346641da8eb8bc052ee3240238e Mon Sep 17 00:00:00 2001 From: hreintke Date: Sat, 26 Jan 2019 12:31:25 +0100 Subject: [PATCH 10/24] Waring and formattin fix --- .../mDNS_ServiceMonitor.ino | 60 +++++++++---------- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 2 +- 2 files changed, 30 insertions(+), 32 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index ebeb178bc0..1c24a09197 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -89,35 +89,33 @@ bool setStationHostname(const char* p_pcHostname) { MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) -{ - String answerInfo; - switch (p_u32ServiceQueryAnswerMask){ - case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : - answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); - break; - case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : - answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); - break; - case MDNSResponder::ServiceQueryAnswerType_IP4Address : - answerInfo = "IP4Address "; - for (IPAddress ip : serviceInfo.IPAdresses()){ - answerInfo += "- " + ip.toString(); - }; - break; - case MDNSResponder::ServiceQueryAnswerType_Txts : - answerInfo = "TXT " + serviceInfo.strKeyValue(); - for (auto kv : serviceInfo.keyValues()) - { - answerInfo += "\nkv : " + kv.first + " : "+ kv.second; - } - break; - default : - answerInfo = "Unknown"; - } - Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); +bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) { + String answerInfo; + switch (p_u32ServiceQueryAnswerMask){ + case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : + answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); + break; + case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : + answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); + break; + case MDNSResponder::ServiceQueryAnswerType_IP4Address : + answerInfo = "IP4Address "; + for (IPAddress ip : serviceInfo.IPAdresses()){ + answerInfo += "- " + ip.toString(); + }; + break; + case MDNSResponder::ServiceQueryAnswerType_Txts : + answerInfo = "TXT " + serviceInfo.strKeyValue(); + for (auto kv : serviceInfo.keyValues()) { + answerInfo += "\nkv : " + kv.first + " : "+ kv.second; + } + break; + default : + answerInfo = "Unknown"; + } + Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); - return true; + return true; } @@ -209,9 +207,9 @@ void handleHTTPRequest() { s += "

      Local HTTP services are :

      "; s += "
        "; for (auto info : MDNS.answerInfo(hMDNSServiceQuery)) { - s += "
      1. "; - s += info.serviceDomain(); - if (info.hostDomainAvailable()) { + s += "
      2. "; + s += info.serviceDomain(); + if (info.hostDomainAvailable()) { s += "
        Hostname: "; s += info.hostDomain() + (info.hostPortAvailable()) ? (":" + String(info.hostPort())) : ""; } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index f56085e09e..b917e38dff 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -815,7 +815,7 @@ uint32_t MDNSResponder::answerCount(const MDNSResponder::hMDNSServiceQuery p_hSe std::vector MDNSResponder::answerInfo (const MDNSResponder::hMDNSServiceQuery p_hServiceQuery) { std::vector tempVector; - for (int i=0;i Date: Sat, 26 Jan 2019 14:06:50 +0100 Subject: [PATCH 11/24] Change struct MDNSServiceInfo { MDNSServiceInfo(MDNSResponder ... to struct MDNSServiceInfo { MDNSServiceInfo(MDNSResponder& --- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 2 +- libraries/ESP8266mDNS/src/LEAmDNS.h | 30 ++++++++++--------- libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp | 16 +++++----- 3 files changed, 25 insertions(+), 23 deletions(-) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index b917e38dff..820019bb03 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -817,7 +817,7 @@ std::vector MDNSResponder::answerInfo (const MD std::vector tempVector; for (uint32_t i=0;ianswerServiceDomain(p_hServiceQuery, p_u32AnswerIndex); + return p_pMDNSResponder.answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex); }; bool hostDomainAvailable() { - return (p_pMDNSResponder->hasAnswerHostDomain(p_hServiceQuery, p_u32AnswerIndex)); + return (p_pMDNSResponder.hasAnswerHostDomain(p_hServiceQuery, p_u32AnswerIndex)); } String hostDomain(){ return (hostDomainAvailable()) ? - p_pMDNSResponder->answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : String(); + p_pMDNSResponder.answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : String(); }; bool hostPortAvailable() { - return (p_pMDNSResponder->hasAnswerPort(p_hServiceQuery, p_u32AnswerIndex)); + return (p_pMDNSResponder.hasAnswerPort(p_hServiceQuery, p_u32AnswerIndex)); } uint16_t hostPort(){ return (hostPortAvailable()) ? - p_pMDNSResponder->answerPort(p_hServiceQuery, p_u32AnswerIndex) : 0; + p_pMDNSResponder.answerPort(p_hServiceQuery, p_u32AnswerIndex) : 0; }; bool IPAddressAvailable() { - return (p_pMDNSResponder->hasAnswerIP4Address(p_hServiceQuery,p_u32AnswerIndex )); + return (p_pMDNSResponder.hasAnswerIP4Address(p_hServiceQuery,p_u32AnswerIndex )); } std::vector IPAdresses(){ std::vector internalIP; if (IPAddressAvailable()) { - for (uint32_t u2 = 0; u2 < p_pMDNSResponder->answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u2) { - internalIP.push_back(p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u2)); + for (uint32_t u2 = 0; u2 < p_pMDNSResponder.answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u2) { + internalIP.push_back(p_pMDNSResponder.answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u2)); } } return internalIP; }; bool txtAvailable() { - return (p_pMDNSResponder->hasAnswerTxts(p_hServiceQuery, p_u32AnswerIndex)); + return (p_pMDNSResponder.hasAnswerTxts(p_hServiceQuery, p_u32AnswerIndex)); } String strKeyValue (){ return (txtAvailable()) ? - p_pMDNSResponder->answerTxts(p_hServiceQuery, p_u32AnswerIndex) : String(); + p_pMDNSResponder.answerTxts(p_hServiceQuery, p_u32AnswerIndex) : String(); }; std::map keyValues() { std::map tempKV; - for (auto kv = p_pMDNSResponder->_answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex);kv != nullptr;kv = kv->m_pNext) { + for (auto kv = p_pMDNSResponder._answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex);kv != nullptr;kv = kv->m_pNext) { tempKV.insert(std::pair(String(kv->m_pcKey),String(kv->m_pcValue))); } return tempKV; @@ -544,7 +546,7 @@ class MDNSResponder { { String result; - for (stcMDNSServiceTxt* pTxt=p_pMDNSResponder->_answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex); pTxt; pTxt=pTxt->m_pNext) { + for (stcMDNSServiceTxt* pTxt=p_pMDNSResponder._answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex); pTxt; pTxt=pTxt->m_pNext) { if ((key.c_str()) && (0 == strcmp(pTxt->m_pcKey, key.c_str()))) { result = String(pTxt->m_pcValue); diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp index 7660fc33d1..a604d76d66 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp @@ -779,7 +779,7 @@ bool MDNSResponder::_processPTRAnswer(const MDNSResponder::stcMDNS_RRAnswerPTR* //Functional p_rbFoundNewKeyAnswer = true; if (pServiceQuery->m_fnCallback) { - MDNSServiceInfo serviceInfo(this,(hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo(*this,(hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_ServiceDomain, true); } } @@ -824,7 +824,7 @@ bool MDNSResponder::_processSRVAnswer(const MDNSResponder::stcMDNS_RRAnswerSRV* p_rbFoundNewKeyAnswer = true; if (pServiceQuery->m_fnCallback) { - MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_HostDomainAndPort, true); } } @@ -872,7 +872,7 @@ bool MDNSResponder::_processTXTAnswer(const MDNSResponder::stcMDNS_RRAnswerTXT* pSQAnswer->releaseTxts(); if (pServiceQuery->m_fnCallback) { - MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo , ServiceQueryAnswerType_Txts, true); } } @@ -938,7 +938,7 @@ bool MDNSResponder::_processTXTAnswer(const MDNSResponder::stcMDNS_RRAnswerTXT* pSQAnswer->m_u32ContentFlags |= ServiceQueryAnswerType_IP4Address; // Functional if (pServiceQuery->m_fnCallback) { - MDNSServiceInfo serviceInfo (this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo (*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_IP4Address, true); } } @@ -1489,7 +1489,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { else { // Timed out! -> Delete if (pServiceQuery->m_fnCallback) { - MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_ServiceDomain, false); } DEBUG_EX_INFO( @@ -1549,7 +1549,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { pSQAnswer->m_u32ContentFlags &= ~u32ContentFlags; //Functional if (pServiceQuery->m_fnCallback) { - MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, u32ContentFlags, false); } } @@ -1586,7 +1586,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { pSQAnswer->m_u32ContentFlags &= ~ServiceQueryAnswerType_Txts; if (pServiceQuery->m_fnCallback) { - MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_Txts, false); } } @@ -1635,7 +1635,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { // Notify client if (pServiceQuery->m_fnCallback) { // Functional - MDNSServiceInfo serviceInfo(this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); + MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_IP4Address, false); } } From db0d502614427dc6fa878666634d0507832d18f0 Mon Sep 17 00:00:00 2001 From: hreintke Date: Sun, 27 Jan 2019 13:46:35 +0100 Subject: [PATCH 12/24] Make AnswerType user friendly --- libraries/ESP8266mDNS/src/LEAmDNS.h | 15 ++++++++++++++- libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp | 16 ++++++++-------- 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 3c80db20de..47861e7ccd 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -358,6 +358,19 @@ class MDNSResponder { #endif } enuServiceQueryAnswerType; + enum class AnswerType : uint32_t { + Unknown = 0, + ServiceDomain = (1 << 0), + HostDomainAndPort = (1 << 1), + Txt = (1 << 2), +#ifdef MDNS_IP4_SUPPORT + IP4Address = (1 << 3), +#endif +#ifdef MDNS_IP6_SUPPORT + IP6Address = (1 << 4), +#endif + }; + /** * MDNSServiceQueryCallbackFn * Callback function for received answers for dynamic service queries @@ -374,7 +387,7 @@ class MDNSResponder { // Functional struct MDNSServiceInfo; // forward declaration typedef std::function MDNSServiceQueryCallbackFunc; diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp index a604d76d66..d5b36b3db6 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp @@ -780,7 +780,7 @@ bool MDNSResponder::_processPTRAnswer(const MDNSResponder::stcMDNS_RRAnswerPTR* p_rbFoundNewKeyAnswer = true; if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this,(hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_ServiceDomain, true); + pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_ServiceDomain), true); } } } @@ -825,7 +825,7 @@ bool MDNSResponder::_processSRVAnswer(const MDNSResponder::stcMDNS_RRAnswerSRV* p_rbFoundNewKeyAnswer = true; if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_HostDomainAndPort, true); + pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_HostDomainAndPort), true); } } } @@ -873,7 +873,7 @@ bool MDNSResponder::_processTXTAnswer(const MDNSResponder::stcMDNS_RRAnswerTXT* if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo , ServiceQueryAnswerType_Txts, true); + pServiceQuery->m_fnCallback(serviceInfo , static_cast(ServiceQueryAnswerType_Txts), true); } } } @@ -939,7 +939,7 @@ bool MDNSResponder::_processTXTAnswer(const MDNSResponder::stcMDNS_RRAnswerTXT* // Functional if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo (*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_IP4Address, true); + pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_IP4Address), true); } } else { @@ -1490,7 +1490,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { // Timed out! -> Delete if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_ServiceDomain, false); + pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_ServiceDomain), false); } DEBUG_EX_INFO( DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _checkServiceQueryCache: Will remove PTR answer for ")); @@ -1550,7 +1550,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { //Functional if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo, u32ContentFlags, false); + pServiceQuery->m_fnCallback(serviceInfo,static_cast(u32ContentFlags), false); } } } // HostDomainAndPort flagged @@ -1587,7 +1587,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_Txts, false); + pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_Txts), false); } } } // TXTs flagged @@ -1636,7 +1636,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) { if (pServiceQuery->m_fnCallback) { // Functional MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); - pServiceQuery->m_fnCallback(serviceInfo, ServiceQueryAnswerType_IP4Address, false); + pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_IP4Address), false); } } } // IP4 flagged From 0ece47451a73ff971e655869d7a4e98e8aa871ac Mon Sep 17 00:00:00 2001 From: hreintke Date: Sun, 27 Jan 2019 13:47:57 +0100 Subject: [PATCH 13/24] Update ServiceInfo example --- .../mDNS_ServiceMonitor.ino | 55 ++++++++++--------- 1 file changed, 29 insertions(+), 26 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 1c24a09197..36737ecd9a 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -89,36 +89,39 @@ bool setStationHostname(const char* p_pcHostname) { MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent) { - String answerInfo; - switch (p_u32ServiceQueryAnswerMask){ - case MDNSResponder::ServiceQueryAnswerType_ServiceDomain : - answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); - break; - case MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort : - answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); - break; - case MDNSResponder::ServiceQueryAnswerType_IP4Address : - answerInfo = "IP4Address "; - for (IPAddress ip : serviceInfo.IPAdresses()){ - answerInfo += "- " + ip.toString(); - }; - break; - case MDNSResponder::ServiceQueryAnswerType_Txts : - answerInfo = "TXT " + serviceInfo.strKeyValue(); - for (auto kv : serviceInfo.keyValues()) { - answerInfo += "\nkv : " + kv.first + " : "+ kv.second; - } - break; - default : - answerInfo = "Unknown"; - } - Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); +bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, MDNSResponder::AnswerType answerType, bool p_bSetContent) +{ + String answerInfo; + switch (answerType){ + case MDNSResponder::AnswerType::ServiceDomain : + answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); + break; + case MDNSResponder::AnswerType::HostDomainAndPort : + answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); + break; + case MDNSResponder::AnswerType::IP4Address : + answerInfo = "IP4Address "; + for (IPAddress ip : serviceInfo.IPAdresses()){ + answerInfo += "- " + ip.toString(); + }; + break; + case MDNSResponder::AnswerType::Txt : + answerInfo = "TXT " + serviceInfo.strKeyValue(); + for (auto kv : serviceInfo.keyValues()) + { + answerInfo += "\nkv : " + kv.first + " : "+ kv.second; + } + break; + default : + answerInfo = "Unknown Answertype"; + } + Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); - return true; + return true; } + /* MDNSServiceProbeResultCallback Probe result callback for Services From fd2cd6728cb7c99a1c24bb87ea03c17ef9ae470d Mon Sep 17 00:00:00 2001 From: hreintke Date: Sun, 27 Jan 2019 14:03:02 +0100 Subject: [PATCH 14/24] Code cleanup --- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 6 ----- libraries/ESP8266mDNS/src/LEAmDNS.h | 24 +------------------ libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp | 8 ------- libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp | 11 ++------- 4 files changed, 3 insertions(+), 46 deletions(-) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index 820019bb03..510b60aab7 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -55,7 +55,6 @@ MDNSResponder::MDNSResponder(void) m_pcHostname(0), m_pServiceQueries(0), m_fnServiceTxtCallback(0), - m_pServiceTxtCallbackUserdata(0), #ifdef ENABLE_ESP_MDNS_RESPONDER_PASSIV_MODE m_bPassivModeEnabled(true) { #else @@ -755,7 +754,6 @@ uint16_t MDNSResponder::port(const uint32_t p_u32AnswerIndex) { * - answerTxts * */ -//Functional MDNSResponder::hMDNSServiceQuery MDNSResponder::installServiceQuery(const char* p_pcService, const char* p_pcProtocol, MDNSResponder::MDNSServiceQueryCallbackFunc p_fnCallback) { @@ -771,7 +769,6 @@ MDNSResponder::hMDNSServiceQuery MDNSResponder::installServiceQuery(const char* (_buildDomainForService(p_pcService, p_pcProtocol, pServiceQuery->m_ServiceTypeDomain))) { pServiceQuery->m_fnCallback = p_fnCallback; - pServiceQuery->m_pUserdata = 0; pServiceQuery->m_bLegacyQuery = false; if (_sendMDNSServiceQuery(*pServiceQuery)) { @@ -1034,11 +1031,9 @@ const char* MDNSResponder::answerTxts(const MDNSResponder::hMDNSServiceQuery p_h * When succeeded, the host or service domain will be announced by the MDNS responder. * */ -//Functional bool MDNSResponder::setHostProbeResultCallback(MDNSResponder::MDNSHostProbeResultCallbackFn p_fnCallback) { m_HostProbeInformation.m_fnHostProbeResultCallback = p_fnCallback; - m_HostProbeInformation.m_pProbeResultCallbackUserdata = 0; return true; } @@ -1060,7 +1055,6 @@ bool MDNSResponder::setServiceProbeResultCallback(const MDNSResponder::hMDNSServ stcMDNSService* pService = _findService(p_hService); if (pService) { pService->m_ProbeInformation.m_fnServiceProbeResultCallback = p_fnCallback; - pService->m_ProbeInformation.m_pProbeResultCallbackUserdata = 0; bResult = true; } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 47861e7ccd..24a9314719 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -277,12 +277,8 @@ class MDNSResponder { * MDNSDynamicServiceTxtCallbackFn * Callback function for dynamic MDNS TXT items */ -// Functional -// typedef bool (*MDNSDynamicServiceTxtCallbackFn)(MDNSResponder* p_pMDNSResponder, -// const hMDNSService p_hService, -// void* p_pUserdata); - typedef std::function MDNSDynamicServiceTxtCallbackFunc; + typedef std::function MDNSDynamicServiceTxtCallbackFunc; // Set a global callback for dynamic MDNS TXT items. The callback function is called // every time, a TXT item is needed for one of the installed services. @@ -375,16 +371,6 @@ class MDNSResponder { * MDNSServiceQueryCallbackFn * Callback function for received answers for dynamic service queries */ -/* - typedef bool (*MDNSServiceQueryCallbackFn)(MDNSResponder* p_pMDNSResponder, - const hMDNSServiceQuery p_hServiceQuery, // dynamic service query handle - uint32_t p_u32AnswerIndex, // index of the updated answer - uint32_t p_u32ServiceQueryAnswerMask, // flag for the updated answer item - bool p_bSetContent, // true: Answer component set, false: component deleted - - void* p_pUserdata); // pUserdata set via 'installServiceQuery' -*/ -// Functional struct MDNSServiceInfo; // forward declaration typedef std::function MDNSHostProbeResultCallbackFn; @@ -462,7 +447,6 @@ class MDNSResponder { // (or a service domain, which hasn't got a service specific callback) // Succeeds or fails. // In case of failure, the failed domain name should be changed. -// Functional bool setHostProbeResultCallback(MDNSHostProbeResultCallbackFn p_fnCallback); // Set a service specific probe result callback @@ -490,7 +474,6 @@ class MDNSResponder { protected: /** STRUCTS **/ -// Functional /** * MDNSServiceInfo, used in application callbacks */ @@ -901,10 +884,8 @@ class MDNSResponder { //clsMDNSTimeFlag m_TimeFlag; // Used for probes and announcements bool m_bConflict; bool m_bTiebreakNeeded; -// Functional MDNSHostProbeResultCallbackFn m_fnHostProbeResultCallback; MDNSServiceProbeResultCallbackFn m_fnServiceProbeResultCallback; - void* m_pProbeResultCallbackUserdata; stcProbeInformation(void); @@ -925,7 +906,6 @@ class MDNSResponder { uint8_t m_u8ReplyMask; stcMDNSServiceTxts m_Txts; MDNSDynamicServiceTxtCallbackFunc m_fnTxtCallback; - void* m_pTxtCallbackUserdata; stcProbeInformation m_ProbeInformation; stcMDNSService(const char* p_pcName = 0, @@ -1069,7 +1049,6 @@ class MDNSResponder { stcMDNSServiceQuery* m_pNext; stcMDNS_RRDomain m_ServiceTypeDomain; // eg. _http._tcp.local MDNSServiceQueryCallbackFunc m_fnCallback; - void* m_pUserdata; bool m_bLegacyQuery; uint8_t m_u8SentCount; esp8266::polledTimeout::oneShot m_ResendTimeout; @@ -1147,7 +1126,6 @@ class MDNSResponder { WiFiEventHandler m_DisconnectedHandler; WiFiEventHandler m_GotIPHandler; MDNSDynamicServiceTxtCallbackFunc m_fnServiceTxtCallback; - void* m_pServiceTxtCallbackUserdata; bool m_bPassivModeEnabled; stcProbeInformation m_HostProbeInformation; diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp index d5b36b3db6..c95c8d8234 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp @@ -776,7 +776,6 @@ bool MDNSResponder::_processPTRAnswer(const MDNSResponder::stcMDNS_RRAnswerPTR* pSQAnswer->releaseServiceDomain(); bResult = pServiceQuery->addAnswer(pSQAnswer); - //Functional p_rbFoundNewKeyAnswer = true; if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this,(hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); @@ -936,7 +935,6 @@ bool MDNSResponder::_processTXTAnswer(const MDNSResponder::stcMDNS_RRAnswerTXT* (pSQAnswer->addIP4Address(pIP4Address))) { pSQAnswer->m_u32ContentFlags |= ServiceQueryAnswerType_IP4Address; -// Functional if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo (*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_IP4Address), true); @@ -1064,7 +1062,6 @@ bool MDNSResponder::_updateProbeStatus(void) { DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done host probing.\n"));); m_HostProbeInformation.m_ProbingStatus = ProbingStatus_Done; m_HostProbeInformation.m_Timeout.reset(std::numeric_limits::max()); -// Functional if (m_HostProbeInformation.m_fnHostProbeResultCallback) { m_HostProbeInformation.m_fnHostProbeResultCallback(m_pcHostname, true); } @@ -1114,7 +1111,6 @@ bool MDNSResponder::_updateProbeStatus(void) { DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done service probing %s.%s.%s\n\n"), (pService->m_pcName ?: m_pcHostname), pService->m_pcService, pService->m_pcProtocol);); pService->m_ProbeInformation.m_ProbingStatus = ProbingStatus_Done; pService->m_ProbeInformation.m_Timeout.reset(std::numeric_limits::max()); -// Functional Update if (pService->m_ProbeInformation.m_fnServiceProbeResultCallback) { pService->m_ProbeInformation.m_fnServiceProbeResultCallback(pService->m_pcName, pService, true); } @@ -1280,7 +1276,6 @@ bool MDNSResponder::_cancelProbingForHost(void) { bool bResult = false; m_HostProbeInformation.clear(false); -// Functional // Send host notification if (m_HostProbeInformation.m_fnHostProbeResultCallback) { m_HostProbeInformation.m_fnHostProbeResultCallback(m_pcHostname, false); @@ -1302,7 +1297,6 @@ bool MDNSResponder::_cancelProbingForService(stcMDNSService& p_rService) { bool bResult = false; p_rService.m_ProbeInformation.clear(false); -// Functional // Send notification if (p_rService.m_ProbeInformation.m_fnServiceProbeResultCallback) { p_rService.m_ProbeInformation.m_fnServiceProbeResultCallback(p_rService.m_pcName,&p_rService,false); @@ -1547,7 +1541,6 @@ bool MDNSResponder::_checkServiceQueryCache(void) { // Remove content flags for deleted answer parts pSQAnswer->m_u32ContentFlags &= ~u32ContentFlags; -//Functional if (pServiceQuery->m_fnCallback) { MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo,static_cast(u32ContentFlags), false); @@ -1634,7 +1627,6 @@ bool MDNSResponder::_checkServiceQueryCache(void) { } // Notify client if (pServiceQuery->m_fnCallback) { -// Functional MDNSServiceInfo serviceInfo(*this, (hMDNSServiceQuery)pServiceQuery, pServiceQuery->indexOfAnswer(pSQAnswer)); pServiceQuery->m_fnCallback(serviceInfo, static_cast(ServiceQueryAnswerType_IP4Address), false); } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp index 7bf3cc0235..41c38fe6b1 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp @@ -1162,10 +1162,8 @@ MDNSResponder::stcProbeInformation::stcProbeInformation(void) m_Timeout(std::numeric_limits::max()), m_bConflict(false), m_bTiebreakNeeded(false), -// Functional m_fnHostProbeResultCallback(0), - m_fnServiceProbeResultCallback(0), - m_pProbeResultCallbackUserdata(0) { + m_fnServiceProbeResultCallback(0) { } /* @@ -1178,11 +1176,9 @@ bool MDNSResponder::stcProbeInformation::clear(bool p_bClearUserdata /*= false*/ m_Timeout.reset(std::numeric_limits::max()); m_bConflict = false; m_bTiebreakNeeded = false; -// Functional if (p_bClearUserdata) { m_fnHostProbeResultCallback = 0; m_fnServiceProbeResultCallback = 0; - m_pProbeResultCallbackUserdata = 0; } return true; } @@ -1211,8 +1207,7 @@ MDNSResponder::stcMDNSService::stcMDNSService(const char* p_pcName /*= 0*/, m_pcProtocol(0), m_u16Port(0), m_u8ReplyMask(0), - m_fnTxtCallback(0), - m_pTxtCallbackUserdata(0) { + m_fnTxtCallback(0) { setName(p_pcName); setService(p_pcService); @@ -1925,7 +1920,6 @@ MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP6Address* MDNSResponder::stc MDNSResponder::stcMDNSServiceQuery::stcMDNSServiceQuery(void) : m_pNext(0), m_fnCallback(0), - m_pUserdata(0), m_bLegacyQuery(false), m_u8SentCount(0), m_ResendTimeout(std::numeric_limits::max()), @@ -1949,7 +1943,6 @@ MDNSResponder::stcMDNSServiceQuery::~stcMDNSServiceQuery(void) { bool MDNSResponder::stcMDNSServiceQuery::clear(void) { m_fnCallback = 0; - m_pUserdata = 0; m_bLegacyQuery = false; m_u8SentCount = 0; m_ResendTimeout.reset(std::numeric_limits::max()); From 88f1547e2ca6b6b56ef598c4f7d12d9a28c38c72 Mon Sep 17 00:00:00 2001 From: hreintke Date: Sun, 27 Jan 2019 16:11:23 +0100 Subject: [PATCH 15/24] AnswerType update, Astyle update servicemonitor --- .../mDNS_ServiceMonitor.ino | 66 +++++++++---------- libraries/ESP8266mDNS/src/LEAmDNS.h | 10 +-- 2 files changed, 37 insertions(+), 39 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 36737ecd9a..7578ed559a 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -89,35 +89,33 @@ bool setStationHostname(const char* p_pcHostname) { MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, MDNSResponder::AnswerType answerType, bool p_bSetContent) -{ - String answerInfo; - switch (answerType){ - case MDNSResponder::AnswerType::ServiceDomain : - answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); - break; - case MDNSResponder::AnswerType::HostDomainAndPort : - answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); - break; - case MDNSResponder::AnswerType::IP4Address : - answerInfo = "IP4Address "; - for (IPAddress ip : serviceInfo.IPAdresses()){ - answerInfo += "- " + ip.toString(); - }; - break; - case MDNSResponder::AnswerType::Txt : - answerInfo = "TXT " + serviceInfo.strKeyValue(); - for (auto kv : serviceInfo.keyValues()) - { - answerInfo += "\nkv : " + kv.first + " : "+ kv.second; - } - break; - default : - answerInfo = "Unknown Answertype"; - } - Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted"); - - return true; +bool MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSResponder::AnswerType answerType, bool p_bSetContent) { + String answerInfo; + switch (answerType) { + case MDNSResponder::AnswerType::ServiceDomain : + answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); + break; + case MDNSResponder::AnswerType::HostDomainAndPort : + answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); + break; + case MDNSResponder::AnswerType::IP4Address : + answerInfo = "IP4Address "; + for (IPAddress ip : serviceInfo.IPAdresses()) { + answerInfo += "- " + ip.toString(); + }; + break; + case MDNSResponder::AnswerType::Txt : + answerInfo = "TXT " + serviceInfo.strKeyValue(); + for (auto kv : serviceInfo.keyValues()) { + answerInfo += "\nkv : " + kv.first + " : " + kv.second; + } + break; + default : + answerInfo = "Unknown Answertype"; + } + Serial.printf("Answer %s %s\n", answerInfo.c_str(), p_bSetContent ? "Modified" : "Deleted"); + + return true; } @@ -213,19 +211,19 @@ void handleHTTPRequest() { s += "
      3. "; s += info.serviceDomain(); if (info.hostDomainAvailable()) { - s += "
        Hostname: "; - s += info.hostDomain() + (info.hostPortAvailable()) ? (":" + String(info.hostPort())) : ""; - } + s += "
        Hostname: "; + s += info.hostDomain() + (info.hostPortAvailable()) ? (":" + String(info.hostPort())) : ""; + } if (info.IPAddressAvailable()) { s += "
        IP4:"; for (auto ip : info.IPAdresses()) { - s += " " + ip.toString(); + s += " " + ip.toString(); } } if (info.txtAvailable()) { s += "
        TXT:
        "; for (auto kv : info.keyValues()) { - s += "\t" + kv.first + " : " + kv.second + "
        "; + s += "\t" + kv.first + " : " + kv.second + "
        "; } } s += "
        4. "; diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 24a9314719..19f3577385 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -356,14 +356,14 @@ class MDNSResponder { enum class AnswerType : uint32_t { Unknown = 0, - ServiceDomain = (1 << 0), - HostDomainAndPort = (1 << 1), - Txt = (1 << 2), + ServiceDomain = ServiceQueryAnswerType_ServiceDomain, + HostDomainAndPort = ServiceQueryAnswerType_HostDomainAndPort, + Txt = ServiceQueryAnswerType_Txts, #ifdef MDNS_IP4_SUPPORT - IP4Address = (1 << 3), + IP4Address = ServiceQueryAnswerType_IP4Address, #endif #ifdef MDNS_IP6_SUPPORT - IP6Address = (1 << 4), + IP6Address = ServiceQueryAnswerType_IP6Address, #endif }; From 819a7e09fdb97adb5bab0ed36fde8515faa4c66d Mon Sep 17 00:00:00 2001 From: hreintke Date: Mon, 28 Jan 2019 16:02:31 +0100 Subject: [PATCH 16/24] Update clock example to webserver --- .../LEAmDNS/mDNS_Clock/mDNS_Clock.ino | 75 +++++-------------- 1 file changed, 20 insertions(+), 55 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino index 75a04b22c4..d195a2165f 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino @@ -34,6 +34,7 @@ #include #include +#include #include /* @@ -72,9 +73,8 @@ char* pcHostDomain = 0; // Negociated bool bHostDomainConfirmed = false; // Flags the confirmation of the host domain MDNSResponder::hMDNSService hMDNSService = 0; // The handle of the clock service in the MDNS responder -// TCP server at port 'SERVICE_PORT' will respond to HTTP requests -WiFiServer server(SERVICE_PORT); - +// HTTP server at port 'SERVICE_PORT' will respond to HTTP requests +ESP8266WebServer server(SERVICE_PORT); /* getTimeString @@ -194,31 +194,10 @@ bool hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { /* handleHTTPClient */ -void handleHTTPClient(WiFiClient& client) { - Serial.println(""); - Serial.println("New client"); - - // Wait for data from client to become available - while (client.connected() && !client.available()) { - delay(1); - } - // Read the first line of HTTP request - String req = client.readStringUntil('\r'); - - // First line of HTTP request looks like "GET /path HTTP/1.1" - // Retrieve the "/path" part by finding the spaces - int addr_start = req.indexOf(' '); - int addr_end = req.indexOf(' ', addr_start + 1); - if (addr_start == -1 || addr_end == -1) { - Serial.print("Invalid request: "); - Serial.println(req); - return; - } - req = req.substring(addr_start + 1, addr_end); - Serial.print("Request: "); - Serial.println(req); - client.flush(); +void handleHTTPRequest() { + Serial.println(""); + Serial.println("HTTP Request"); // Get current time time_t now = time(nullptr);; @@ -226,27 +205,18 @@ void handleHTTPClient(WiFiClient& client) { gmtime_r(&now, &timeinfo); String s; - if (req == "/") { - IPAddress ip = WiFi.localIP(); - String ipStr = String(ip[0]) + '.' + String(ip[1]) + '.' + String(ip[2]) + '.' + String(ip[3]); - s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n\r\nHello from "; - s += WiFi.hostname() + " at " + ipStr; - // Simple addition of the current time - s += "\r\nCurrent time is: "; - s += getTimeString(); - // done :-) - s += "\r\n\r\n"; - Serial.println("Sending 200"); - } else { - s = "HTTP/1.1 404 Not Found\r\n\r\n"; - Serial.println("Sending 404"); - } - client.print(s); - Serial.println("Done with client"); + s = "\r\nHello from "; + s += WiFi.hostname() + " at " + WiFi.localIP().toString(); + // Simple addition of the current time + s += "\r\nCurrent time is: "; + s += getTimeString(); + // done :-) + s += "\r\n\r\n"; + Serial.println("Sending 200"); + server.send(200, "text/html", s); } - /* setup */ @@ -284,27 +254,22 @@ void setup(void) { } Serial.println("MDNS responder started"); - // Start TCP (HTTP) server + // Setup HTTP server + server.on("/", handleHTTPRequest); server.begin(); - Serial.println("TCP server started"); + Serial.println("HTTP server started"); } - /* loop */ void loop(void) { - // Check if a client has connected - WiFiClient client = server.available(); - if (client) { - handleHTTPClient(client); - } + // Check if a request has come in + server.handleClient(); // Allow MDNS processing MDNS.update(); - // Update time (if needed) - //static unsigned long ulNextTimeUpdate = UPDATE_CYCLE; static esp8266::polledTimeout::periodic timeout(UPDATE_CYCLE); if (timeout.expired()) { From f667b56c0b2084035c3cd2da4d28f78720673a22 Mon Sep 17 00:00:00 2001 From: hreintke Date: Tue, 29 Jan 2019 11:51:13 +0100 Subject: [PATCH 17/24] Second typedef for probe callbacks Change String -> const char* at multiple locations --- .../mDNS_ServiceMonitor.ino | 20 +++---- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 20 ++++++- libraries/ESP8266mDNS/src/LEAmDNS.h | 52 ++++++++++++------- 3 files changed, 58 insertions(+), 34 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 7578ed559a..228ff43c9d 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -93,19 +93,19 @@ bool MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSRe String answerInfo; switch (answerType) { case MDNSResponder::AnswerType::ServiceDomain : - answerInfo = "ServiceDomain " + serviceInfo.serviceDomain(); + answerInfo = "ServiceDomain " + String(serviceInfo.serviceDomain()); break; case MDNSResponder::AnswerType::HostDomainAndPort : - answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort()); + answerInfo = "HostDomainAndPort " + String(serviceInfo.hostDomain()) + ":" + String(serviceInfo.hostPort()); break; case MDNSResponder::AnswerType::IP4Address : answerInfo = "IP4Address "; - for (IPAddress ip : serviceInfo.IPAdresses()) { + for (IPAddress ip : serviceInfo.IP4Adresses()) { answerInfo += "- " + ip.toString(); }; break; case MDNSResponder::AnswerType::Txt : - answerInfo = "TXT " + serviceInfo.strKeyValue(); + answerInfo = "TXT " + String(serviceInfo.strKeyValue()); for (auto kv : serviceInfo.keyValues()) { answerInfo += "\nkv : " + kv.first + " : " + kv.second; } @@ -118,8 +118,6 @@ bool MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSRe return true; } - - /* MDNSServiceProbeResultCallback Probe result callback for Services @@ -133,8 +131,6 @@ bool serviceProbeResult(String p_pcServiceName, return true; } - - /* MDNSHostProbeResultCallback @@ -212,11 +208,12 @@ void handleHTTPRequest() { s += info.serviceDomain(); if (info.hostDomainAvailable()) { s += "
        Hostname: "; - s += info.hostDomain() + (info.hostPortAvailable()) ? (":" + String(info.hostPort())) : ""; + s += String(info.hostDomain()); + s += (info.hostPortAvailable()) ? (":" + String(info.hostPort())) : ""; } - if (info.IPAddressAvailable()) { + if (info.IP4AddressAvailable()) { s += "
        IP4:"; - for (auto ip : info.IPAdresses()) { + for (auto ip : info.IP4Adresses()) { s += " " + ip.toString(); } } @@ -287,4 +284,3 @@ void loop(void) { MDNS.update(); } - diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index 510b60aab7..289072ee47 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -1031,13 +1031,20 @@ const char* MDNSResponder::answerTxts(const MDNSResponder::hMDNSServiceQuery p_h * When succeeded, the host or service domain will be announced by the MDNS responder. * */ -bool MDNSResponder::setHostProbeResultCallback(MDNSResponder::MDNSHostProbeResultCallbackFn p_fnCallback) { +bool MDNSResponder::setHostProbeResultCallback(MDNSResponder::MDNSHostProbeFn p_fnCallback) { m_HostProbeInformation.m_fnHostProbeResultCallback = p_fnCallback; return true; } +bool MDNSResponder::setHostProbeResultCallback(MDNSHostProbeFn1 pfn) { + + return setHostProbeResultCallback(std::bind(pfn,*this, + std::placeholders::_1, + std::placeholders::_2)); +} + /* * MDNSResponder::setServiceProbeResultCallback * @@ -1048,7 +1055,7 @@ bool MDNSResponder::setHostProbeResultCallback(MDNSResponder::MDNSHostProbeResul * */ bool MDNSResponder::setServiceProbeResultCallback(const MDNSResponder::hMDNSService p_hService, - MDNSResponder::MDNSServiceProbeResultCallbackFn p_fnCallback) { + MDNSResponder::MDNSServiceProbeFn p_fnCallback) { bool bResult = false; @@ -1061,6 +1068,15 @@ bool MDNSResponder::setServiceProbeResultCallback(const MDNSResponder::hMDNSServ return bResult; } +bool MDNSResponder::setServiceProbeResultCallback(const MDNSResponder::hMDNSService p_hService, + MDNSResponder::MDNSServiceProbeFn1 p_fnCallback) { + return setServiceProbeResultCallback(p_hService, + std::bind(p_fnCallback, *this, + std::placeholders::_1, + std::placeholders::_2, + std::placeholders::_3)); +} + /* * MISC diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 19f3577385..dae1cddc20 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -435,23 +435,35 @@ class MDNSResponder { * MDNSProbeResultCallbackFn * Callback function for (host and service domain) probe results */ - typedef std::function MDNSHostProbeResultCallbackFn; + typedef std::function MDNSHostProbeFn; - typedef std::function MDNSServiceProbeResultCallbackFn; + typedef std::function MDNSHostProbeFn1; + + typedef std::function MDNSServiceProbeFn; + + typedef std::function MDNSServiceProbeFn1; // Set a global callback function for host and service probe results // The callback function is called, when the probing for the host domain // (or a service domain, which hasn't got a service specific callback) // Succeeds or fails. // In case of failure, the failed domain name should be changed. - bool setHostProbeResultCallback(MDNSHostProbeResultCallbackFn p_fnCallback); + bool setHostProbeResultCallback(MDNSHostProbeFn p_fnCallback); + bool setHostProbeResultCallback(MDNSHostProbeFn1 p_fnCallback); // Set a service specific probe result callback bool setServiceProbeResultCallback(const MDNSResponder::hMDNSService p_hService, - MDNSServiceProbeResultCallbackFn p_fnCallback); + MDNSServiceProbeFn p_fnCallback); + bool setServiceProbeResultCallback(const MDNSResponder::hMDNSService p_hService, + MDNSServiceProbeFn1 p_fnCallback); // Application should call this whenever AP is configured/disabled bool notifyAPChange(void); @@ -490,16 +502,16 @@ class MDNSResponder { MDNSResponder::hMDNSServiceQuery p_hServiceQuery; uint32_t p_u32AnswerIndex; public: - String serviceDomain(){ + const char* serviceDomain(){ return p_pMDNSResponder.answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex); }; bool hostDomainAvailable() { return (p_pMDNSResponder.hasAnswerHostDomain(p_hServiceQuery, p_u32AnswerIndex)); } - String hostDomain(){ + const char* hostDomain(){ return (hostDomainAvailable()) ? - p_pMDNSResponder.answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : String(); + p_pMDNSResponder.answerHostDomain(p_hServiceQuery, p_u32AnswerIndex) : nullptr; }; bool hostPortAvailable() { @@ -509,13 +521,13 @@ class MDNSResponder { return (hostPortAvailable()) ? p_pMDNSResponder.answerPort(p_hServiceQuery, p_u32AnswerIndex) : 0; }; - bool IPAddressAvailable() + bool IP4AddressAvailable() { return (p_pMDNSResponder.hasAnswerIP4Address(p_hServiceQuery,p_u32AnswerIndex )); } - std::vector IPAdresses(){ + std::vector IP4Adresses(){ std::vector internalIP; - if (IPAddressAvailable()) { + if (IP4AddressAvailable()) { for (uint32_t u2 = 0; u2 < p_pMDNSResponder.answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u2) { internalIP.push_back(p_pMDNSResponder.answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u2)); } @@ -526,9 +538,9 @@ class MDNSResponder { { return (p_pMDNSResponder.hasAnswerTxts(p_hServiceQuery, p_u32AnswerIndex)); } - String strKeyValue (){ + const char* strKeyValue (){ return (txtAvailable()) ? - p_pMDNSResponder.answerTxts(p_hServiceQuery, p_u32AnswerIndex) : String(); + p_pMDNSResponder.answerTxts(p_hServiceQuery, p_u32AnswerIndex) : nullptr; }; std::map keyValues() { @@ -538,14 +550,14 @@ class MDNSResponder { } return tempKV; } - String value(String key) + const char* value(String key) { - String result; + char* result = nullptr; for (stcMDNSServiceTxt* pTxt=p_pMDNSResponder._answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex); pTxt; pTxt=pTxt->m_pNext) { if ((key.c_str()) && (0 == strcmp(pTxt->m_pcKey, key.c_str()))) { - result = String(pTxt->m_pcValue); + result = pTxt->m_pcValue; break; } } @@ -884,8 +896,8 @@ class MDNSResponder { //clsMDNSTimeFlag m_TimeFlag; // Used for probes and announcements bool m_bConflict; bool m_bTiebreakNeeded; - MDNSHostProbeResultCallbackFn m_fnHostProbeResultCallback; - MDNSServiceProbeResultCallbackFn m_fnServiceProbeResultCallback; + MDNSHostProbeFn m_fnHostProbeResultCallback; + MDNSServiceProbeFn m_fnServiceProbeResultCallback; stcProbeInformation(void); From 7068938fa0e93640072ba13514366ed2c26b22b2 Mon Sep 17 00:00:00 2001 From: hreintke Date: Fri, 1 Feb 2019 16:05:17 +0100 Subject: [PATCH 18/24] Optimizations --- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 15 +++++---------- libraries/ESP8266mDNS/src/LEAmDNS.h | 17 +++++++++-------- libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp | 2 +- 3 files changed, 15 insertions(+), 19 deletions(-) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index bb3f9d78d2..4c8bee79d7 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -819,7 +819,7 @@ std::vector MDNSResponder::answerInfo (const MD std::vector tempVector; for (uint32_t i=0;i IP4Adresses(){ std::vector internalIP; if (IP4AddressAvailable()) { - for (uint32_t u2 = 0; u2 < p_pMDNSResponder.answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u2) { - internalIP.push_back(p_pMDNSResponder.answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u2)); + uint16_t cntIP4Adress = p_pMDNSResponder.answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); + for (uint32_t u2 = 0; u2 < cntIP4Adress; ++u2) { + internalIP.emplace_back(p_pMDNSResponder.answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u2)); } } return internalIP; @@ -545,18 +546,18 @@ class MDNSResponder { std::map keyValues() { std::map tempKV; - for (auto kv = p_pMDNSResponder._answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex);kv != nullptr;kv = kv->m_pNext) { + for (auto kv = p_pMDNSResponder._answerKeyValue(p_hServiceQuery, p_u32AnswerIndex);kv != nullptr;kv = kv->m_pNext) { tempKV.insert(std::pair(String(kv->m_pcKey),String(kv->m_pcValue))); } return tempKV; } - const char* value(String key) + const char* value(const char* key) { char* result = nullptr; - for (stcMDNSServiceTxt* pTxt=p_pMDNSResponder._answerKeyvalue(p_hServiceQuery, p_u32AnswerIndex); pTxt; pTxt=pTxt->m_pNext) { - if ((key.c_str()) && - (0 == strcmp(pTxt->m_pcKey, key.c_str()))) { + for (stcMDNSServiceTxt* pTxt=p_pMDNSResponder._answerKeyValue(p_hServiceQuery, p_u32AnswerIndex); pTxt; pTxt=pTxt->m_pNext) { + if ((key) && + (0 == strcmp(pTxt->m_pcKey, key))) { result = pTxt->m_pcValue; break; } @@ -1372,7 +1373,7 @@ class MDNSResponder { const char* p_pcValue, bool p_bTemp); - stcMDNSServiceTxt* _answerKeyvalue(const hMDNSServiceQuery p_hServiceQuery, + stcMDNSServiceTxt* _answerKeyValue(const hMDNSServiceQuery p_hServiceQuery, const uint32_t p_u32AnswerIndex); bool _collectServiceTxts(stcMDNSService& p_rService); diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp index ec37709d06..36f3547e82 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp @@ -629,7 +629,7 @@ MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_addServiceTxt(MDNSResponder::s return pResult; } -MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_answerKeyvalue(const hMDNSServiceQuery p_hServiceQuery, +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); From 772d633a10640bd27d2e5cae867fba7e4541a241 Mon Sep 17 00:00:00 2001 From: hreintke Date: Fri, 1 Feb 2019 16:32:45 +0100 Subject: [PATCH 19/24] Update callbacks to void --- .../LEAmDNS/mDNS_Clock/mDNS_Clock.ino | 5 +--- .../mDNS_ServiceMonitor.ino | 19 +++++++------- libraries/ESP8266mDNS/src/LEAmDNS.h | 26 +++++++++---------- 3 files changed, 23 insertions(+), 27 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino index d195a2165f..458dc73f3f 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino @@ -156,7 +156,7 @@ bool MDNSDynamicServiceTxtCallback(const MDNSResponder::hMDNSService p_hService) restarted via p_pMDNSResponder->setHostname(). */ -bool hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { +void hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { Serial.println("MDNSProbeResultCallback"); Serial.printf("MDNSProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); @@ -187,7 +187,6 @@ bool hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); } } - return true; } @@ -280,5 +279,3 @@ void loop(void) { } } } - - diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 228ff43c9d..c1c1c912ea 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -82,14 +82,15 @@ bool setStationHostname(const char* p_pcHostname) { if (p_pcHostname) { WiFi.hostname(p_pcHostname); Serial.printf("setStationHostname: Station hostname is set to '%s'\n", p_pcHostname); + return true; } - return true; + return false; } /* MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSResponder::AnswerType answerType, bool p_bSetContent) { +void MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSResponder::AnswerType answerType, bool p_bSetContent) { String answerInfo; switch (answerType) { case MDNSResponder::AnswerType::ServiceDomain : @@ -114,21 +115,20 @@ bool MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSRe answerInfo = "Unknown Answertype"; } Serial.printf("Answer %s %s\n", answerInfo.c_str(), p_bSetContent ? "Modified" : "Deleted"); - - return true; } + + /* MDNSServiceProbeResultCallback Probe result callback for Services */ -bool serviceProbeResult(String p_pcServiceName, +void serviceProbeResult(String p_pcServiceName, const MDNSResponder::hMDNSService p_hMDNSService, bool p_bProbeResult) { (void) p_hMDNSService; Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!")); - return true; } /* @@ -142,7 +142,7 @@ bool serviceProbeResult(String p_pcServiceName, */ -bool hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { +void hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { Serial.printf("MDNSHostProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!")); @@ -186,8 +186,6 @@ bool hostProbeResult(String p_pcDomainName, bool p_bProbeResult) { Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); } } - - return true; } /* @@ -282,5 +280,6 @@ void loop(void) { server.handleClient(); // Allow MDNS processing MDNS.update(); - } + + diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 005975034a..eff647b272 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -372,7 +372,7 @@ class MDNSResponder { * Callback function for received answers for dynamic service queries */ struct MDNSServiceInfo; // forward declaration - typedef std::function MDNSServiceQueryCallbackFunc; @@ -435,21 +435,21 @@ class MDNSResponder { * MDNSProbeResultCallbackFn * Callback function for (host and service domain) probe results */ - typedef std::function MDNSHostProbeFn; + typedef std::function MDNSHostProbeFn; - typedef std::function MDNSHostProbeFn1; + typedef std::function MDNSHostProbeFn1; - typedef std::function MDNSServiceProbeFn; + typedef std::function MDNSServiceProbeFn; - typedef std::function MDNSServiceProbeFn1; + typedef std::function MDNSServiceProbeFn1; // Set a global callback function for host and service probe results // The callback function is called, when the probing for the host domain From c1899026eae76af7359277c6ac44a069e3614ae1 Mon Sep 17 00:00:00 2001 From: hreintke Date: Fri, 1 Feb 2019 16:43:47 +0100 Subject: [PATCH 20/24] esp32 compatibility --- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 12 ++++++++++++ libraries/ESP8266mDNS/src/LEAmDNS.h | 5 ++++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index 4c8bee79d7..ff9900b486 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -147,6 +147,18 @@ bool MDNSResponder::close(void) { return true; } +/* + * MDNSResponder::end + * + * Ends the MDNS responder. + * for compatibility with esp32 + * + */ + +bool MDNSResponder::end(void) { + return close(); +} + /* * MDNSResponder::setHostname * diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index eff647b272..81f3d873c8 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -188,7 +188,8 @@ class MDNSResponder { } // Finish MDNS processing bool close(void); - + // for esp32 compatability + bool end(void); // Change hostname (probing is restarted) bool setHostname(const char* p_pcHostname); // for compatibility... @@ -225,6 +226,8 @@ class MDNSResponder { //Warning: this has the side effect of changing the hostname. //TODO: implement instancename different from hostname void setInstanceName(const char* p_pcHostname) {setHostname(p_pcHostname);} + // for esp32 compatibilty + void setInstanceName(const String& s_pcHostname) {setInstanceName(s_pcHostname.c_str());} /** * hMDNSTxt (opaque handle to access the TXT items) From 8d3f9123a4f1821b5cbee0b69dd74d01d8377161 Mon Sep 17 00:00:00 2001 From: hreintke Date: Sun, 3 Feb 2019 16:19:16 +0100 Subject: [PATCH 21/24] std::map to const char* --- .../mDNS_ServiceMonitor.ino | 8 +++---- libraries/ESP8266mDNS/src/LEAmDNS.h | 21 ++++++++++++++----- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index c1c1c912ea..98269fb48e 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -108,7 +108,7 @@ void MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSRe case MDNSResponder::AnswerType::Txt : answerInfo = "TXT " + String(serviceInfo.strKeyValue()); for (auto kv : serviceInfo.keyValues()) { - answerInfo += "\nkv : " + kv.first + " : " + kv.second; + answerInfo += "\nkv : " + String(kv.first) + " : " + String(kv.second); } break; default : @@ -117,8 +117,6 @@ void MDNSServiceQueryCallback(MDNSResponder::MDNSServiceInfo serviceInfo, MDNSRe Serial.printf("Answer %s %s\n", answerInfo.c_str(), p_bSetContent ? "Modified" : "Deleted"); } - - /* MDNSServiceProbeResultCallback Probe result callback for Services @@ -218,7 +216,7 @@ void handleHTTPRequest() { if (info.txtAvailable()) { s += "
        TXT:
        "; for (auto kv : info.keyValues()) { - s += "\t" + kv.first + " : " + kv.second + "
        "; + s += "\t" + String(kv.first) + " : " + String(kv.second) + "
        "; } } s += ""; @@ -259,7 +257,6 @@ void setup(void) { // Setup MDNS responders MDNS.setHostProbeResultCallback(hostProbeResult); - // Init the (currently empty) host domain string with 'esp8266' if ((!MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || (!MDNS.begin(pcHostDomain))) { @@ -283,3 +280,4 @@ void loop(void) { } + diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index 81f3d873c8..eab9e40b15 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -500,10 +500,19 @@ class MDNSResponder { p_hServiceQuery(p_hS), p_u32AnswerIndex(p_u32A) {}; + struct CompareKey + { + bool operator()(char const *a, char const *b) const + { + return strcmp(a, b) < 0; + } + }; + using KeyValueMap = std::map; protected: MDNSResponder& p_pMDNSResponder; MDNSResponder::hMDNSServiceQuery p_hServiceQuery; uint32_t p_u32AnswerIndex; + KeyValueMap keyValueMap; public: const char* serviceDomain(){ return p_pMDNSResponder.answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex); @@ -546,13 +555,15 @@ class MDNSResponder { return (txtAvailable()) ? p_pMDNSResponder.answerTxts(p_hServiceQuery, p_u32AnswerIndex) : nullptr; }; - std::map keyValues() + const KeyValueMap& keyValues() { - std::map tempKV; - for (auto kv = p_pMDNSResponder._answerKeyValue(p_hServiceQuery, p_u32AnswerIndex);kv != nullptr;kv = kv->m_pNext) { - tempKV.insert(std::pair(String(kv->m_pcKey),String(kv->m_pcValue))); + if (txtAvailable() && keyValueMap.size() == 0) + { + for (auto kv = p_pMDNSResponder._answerKeyValue(p_hServiceQuery, p_u32AnswerIndex);kv != nullptr;kv = kv->m_pNext) { + keyValueMap.emplace(std::pair(kv->m_pcKey,kv->m_pcValue)); + } } - return tempKV; + return keyValueMap; } const char* value(const char* key) { From 603b659247458ac2de2dc2a27d48757bf68699d0 Mon Sep 17 00:00:00 2001 From: hreintke Date: Mon, 4 Feb 2019 11:20:29 +0100 Subject: [PATCH 22/24] Fix emplace_back call --- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index ff9900b486..d035881858 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -831,7 +831,7 @@ std::vector MDNSResponder::answerInfo (const MD std::vector tempVector; for (uint32_t i=0;i Date: Mon, 4 Feb 2019 11:21:11 +0100 Subject: [PATCH 23/24] Change Dynamic callback to void(...) --- .../examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino | 3 +-- libraries/ESP8266mDNS/src/LEAmDNS.h | 2 +- libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp | 15 +++++++-------- 3 files changed, 9 insertions(+), 11 deletions(-) diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino index 458dc73f3f..0c6f24ca87 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino @@ -135,14 +135,13 @@ bool setStationHostname(const char* p_pcHostname) { This can be triggered by calling MDNS.announce(). */ -bool MDNSDynamicServiceTxtCallback(const MDNSResponder::hMDNSService p_hService) { +void MDNSDynamicServiceTxtCallback(const MDNSResponder::hMDNSService p_hService) { Serial.println("MDNSDynamicServiceTxtCallback"); if (hMDNSService == p_hService) { Serial.printf("Updating curtime TXT item to: %s\n", getTimeString()); MDNS.addDynamicServiceTxt(p_hService, "curtime", getTimeString()); } - return true; } diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h index eab9e40b15..d35df1fbd3 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -281,7 +281,7 @@ class MDNSResponder { * Callback function for dynamic MDNS TXT items */ - typedef std::function MDNSDynamicServiceTxtCallbackFunc; + typedef std::function MDNSDynamicServiceTxtCallbackFunc; // Set a global callback for dynamic MDNS TXT items. The callback function is called // every time, a TXT item is needed for one of the installed services. diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp index 36f3547e82..d99a57f24a 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp @@ -642,15 +642,14 @@ MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_answerKeyValue(const hMDNSServ */ bool MDNSResponder::_collectServiceTxts(MDNSResponder::stcMDNSService& p_rService) { - bool bResult = (m_fnServiceTxtCallback - ? m_fnServiceTxtCallback((hMDNSService)&p_rService) - : true); - - if ((bResult) && - (p_rService.m_fnTxtCallback)) { - bResult = p_rService.m_fnTxtCallback((hMDNSService)&p_rService); + // Call Dynamic service callbacks + if (m_fnServiceTxtCallback) { + m_fnServiceTxtCallback((hMDNSService)&p_rService); } - return bResult; + if (p_rService.m_fnTxtCallback) { + p_rService.m_fnTxtCallback((hMDNSService)&p_rService); + } + return true; } /* From 0f0edb59f0bb0dbd44e268f6dc5c4a7a5b837196 Mon Sep 17 00:00:00 2001 From: hreintke Date: Mon, 4 Feb 2019 19:58:58 +0100 Subject: [PATCH 24/24] Add WiFi events reset() in close() --- libraries/ESP8266mDNS/src/LEAmDNS.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp index d035881858..1b45b9950f 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -137,7 +137,10 @@ bool MDNSResponder::begin(const char* p_pcHostname, */ bool MDNSResponder::close(void) { - _announce(false, true); + m_GotIPHandler.reset(); // reset WiFi event callbacks. + m_DisconnectedHandler.reset(); + + _announce(false, true); _resetProbeStatus(false); // Stop probing _releaseServiceQueries();