diff --git a/cores/esp8266/PolledTimeout.h b/cores/esp8266/PolledTimeout.h index 7b54577bc..d13bae200 100644 --- a/cores/esp8266/PolledTimeout.h +++ b/cores/esp8266/PolledTimeout.h @@ -23,7 +23,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ - +#include namespace esp8266 { @@ -71,7 +71,7 @@ public: return expired(); } - void reset(timeType newTimeout) + void reset(const timeType newTimeout) { _timeout = newTimeout; reset(); @@ -81,12 +81,18 @@ public: { _start = millis(); } + + timeType getTimeout() const + { + return _timeout; + } -protected: - bool checkExpired(timeType t) const + bool checkExpired(const timeType t) const { return (t - _start) >= _timeout; } + +protected: bool expiredRetrigger() { diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino index 95bfb53fb..0558f3f0d 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_Clock/mDNS_Clock.ino @@ -49,8 +49,7 @@ */ #include -#include - +#include /* Global defines and vars */ @@ -66,15 +65,15 @@ #define STAPSK "your-password" #endif -const char* ssid = STASSID; -const char* password = STAPSK; +const char* ssid = STASSID; +const char* password = STAPSK; -char* pcHostDomain = 0; // Negociated host domain -bool bHostDomainConfirmed = false; // Flags the confirmation of the host domain -LEAmDNS::MDNSResponder::hMDNSService hMDNSService = 0; // The handle of the clock service in the MDNS responder +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 // TCP server at port 'SERVICE_PORT' will respond to HTTP requests -WiFiServer server(SERVICE_PORT); +WiFiServer server(SERVICE_PORT); /* @@ -86,7 +85,7 @@ const char* getTimeString(void) { time_t now = time(nullptr); ctime_r(&now, acTimeString); size_t stLength; - while (((stLength = os_strlen(acTimeString))) && + while (((stLength = strlen(acTimeString))) && ('\n' == acTimeString[stLength - 1])) { acTimeString[stLength - 1] = 0; // Remove trailing line break... } @@ -136,8 +135,8 @@ bool setStationHostname(const char* p_pcHostname) { This can be triggered by calling MDNS.announce(). */ -bool MDNSDynamicServiceTxtCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, - const LEAmDNS::MDNSResponder::hMDNSService p_hService, +bool MDNSDynamicServiceTxtCallback(MDNSResponder* p_pMDNSResponder, + const MDNSResponder::hMDNSService p_hService, void* p_pUserdata) { Serial.println("MDNSDynamicServiceTxtCallback"); (void) p_pUserdata; @@ -161,9 +160,9 @@ bool MDNSDynamicServiceTxtCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, restarted via p_pMDNSResponder->setHostname(). */ -bool MDNSProbeResultCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, +bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder, const char* p_pcDomainName, - const LEAmDNS::MDNSResponder::hMDNSService p_hService, + const MDNSResponder::hMDNSService p_hService, bool p_bProbeResult, void* p_pUserdata) { Serial.println("MDNSProbeResultCallback"); @@ -192,7 +191,7 @@ bool MDNSProbeResultCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, } } else { // Change hostname, use '-' as divider between base name and index - if (LEAmDNS::MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { + if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { p_pMDNSResponder->setHostname(pcHostDomain); } else { Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); @@ -286,10 +285,10 @@ void setup(void) { setClock(); // Setup MDNS responder - LEAmDNS::MDNS.setProbeResultCallback(MDNSProbeResultCallback, 0); + MDNS.setProbeResultCallback(MDNSProbeResultCallback, 0); // Init the (currently empty) host domain string with 'esp8266' - if ((!LEAmDNS::MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || - (!LEAmDNS::MDNS.begin(pcHostDomain))) { + if ((!MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || + (!MDNS.begin(pcHostDomain))) { Serial.println("Error setting up MDNS responder!"); while (1) { // STOP delay(1000); @@ -314,17 +313,17 @@ void loop(void) { } // Allow MDNS processing - LEAmDNS::MDNS.update(); + MDNS.update(); // Update time (if needed) //static unsigned long ulNextTimeUpdate = UPDATE_CYCLE; - static clsLEATimeFlag timeFlag(UPDATE_CYCLE); + static clsMDNSTimeFlag timeFlag(UPDATE_CYCLE); if (timeFlag.flagged()/*ulNextTimeUpdate < millis()*/) { if (hMDNSService) { // Just trigger a new MDNS announcement, this will lead to a call to // 'MDNSDynamicServiceTxtCallback', which will update the time TXT item - LEAmDNS::MDNS.announce(); + MDNS.announce(); } //ulNextTimeUpdate = (millis() + UPDATE_CYCLE); // Set update 'timer' timeFlag.restart(); diff --git a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino index 20bc05ad9..b9a524c32 100644 --- a/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino +++ b/libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino @@ -58,19 +58,19 @@ #define STAPSK "your-password" #endif -const char* ssid = STASSID; -const char* password = STAPSK; +const char* ssid = STASSID; +const char* password = STAPSK; -char* pcHostDomain = 0; // Negociated host domain -bool bHostDomainConfirmed = false; // Flags the confirmation of the host domain -LEAmDNS::MDNSResponder::hMDNSService hMDNSService = 0; // The handle of the http service in the MDNS responder -LEAmDNS::MDNSResponder::hMDNSServiceQuery hMDNSServiceQuery = 0; // The handle of the 'http.tcp' service query in the MDNS responder +char* pcHostDomain = 0; // Negociated host domain +bool bHostDomainConfirmed = false; // Flags the confirmation of the host domain +MDNSResponder::hMDNSService hMDNSService = 0; // The handle of the http service in the MDNS responder +MDNSResponder::hMDNSServiceQuery hMDNSServiceQuery = 0; // The handle of the 'http.tcp' service query in the MDNS responder -const String cstrNoHTTPServices = "Currently no 'http.tcp' services in the local network!
"; -String strHTTPServices = cstrNoHTTPServices; +const String cstrNoHTTPServices = "Currently no 'http.tcp' services in the local network!
"; +String strHTTPServices = cstrNoHTTPServices; // TCP server at port 'SERVICE_PORT' will respond to HTTP requests -WiFiServer server(SERVICE_PORT); +WiFiServer server(SERVICE_PORT); /* @@ -89,24 +89,24 @@ bool setStationHostname(const char* p_pcHostname) { /* MDNSServiceQueryCallback */ -bool MDNSServiceQueryCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, // The MDNS responder object - const LEAmDNS::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' +bool MDNSServiceQueryCallback(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 (LEAmDNS::MDNSResponder::ServiceQueryAnswerType_ServiceDomain & p_u32ServiceQueryAnswerMask) { + 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 (LEAmDNS::MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort & p_u32ServiceQueryAnswerMask) { + } 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), @@ -116,7 +116,7 @@ bool MDNSServiceQueryCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, Serial.printf("MDNSServiceQueryCallback: Host domain and port removed from service '%s'\n", p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); } - } else if (LEAmDNS::MDNSResponder::ServiceQueryAnswerType_IP4Address & p_u32ServiceQueryAnswerMask) { + } else if (MDNSResponder::ServiceQueryAnswerType_IP4Address & p_u32ServiceQueryAnswerMask) { if (p_bSetContent) { Serial.printf("MDNSServiceQueryCallback: IP4 address added/updated for service '%s':\n", p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); @@ -127,7 +127,7 @@ bool MDNSServiceQueryCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, Serial.printf("MDNSServiceQueryCallback: IP4 address removed from service '%s'\n", p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex)); } - } else if (LEAmDNS::MDNSResponder::ServiceQueryAnswerType_Txts & p_u32ServiceQueryAnswerMask) { + } 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), @@ -192,9 +192,9 @@ bool MDNSServiceQueryCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, restarted via p_pMDNSResponder->setHostname(). */ -bool MDNSProbeResultCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, +bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder, const char* p_pcDomainName, - const LEAmDNS::MDNSResponder::hMDNSService p_hService, + const MDNSResponder::hMDNSService p_hService, bool p_bProbeResult, void* p_pUserdata) { (void) p_pUserdata; @@ -235,7 +235,7 @@ bool MDNSProbeResultCallback(LEAmDNS::MDNSResponder* p_pMDNSResponder, } } else { // Change hostname, use '-' as divider between base name and index - if (LEAmDNS::MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { + if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) { p_pMDNSResponder->setHostname(pcHostDomain); } else { Serial.println("MDNSProbeResultCallback: FAILED to update hostname!"); @@ -322,10 +322,10 @@ void setup(void) { Serial.println(WiFi.localIP()); // Setup MDNS responder - LEAmDNS::MDNS.setProbeResultCallback(MDNSProbeResultCallback, 0); + MDNS.setProbeResultCallback(MDNSProbeResultCallback, 0); // Init the (currently empty) host domain string with 'esp8266' - if ((!LEAmDNS::MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || - (!LEAmDNS::MDNS.begin(pcHostDomain))) { + if ((!MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) || + (!MDNS.begin(pcHostDomain))) { Serial.println("Error setting up MDNS responder!"); while (1) { // STOP delay(1000); @@ -350,7 +350,7 @@ void loop(void) { } // Allow MDNS processing - LEAmDNS::MDNS.update(); + MDNS.update(); } diff --git a/libraries/ESP8266mDNS/src/ESP8266mDNS.cpp b/libraries/ESP8266mDNS/src/ESP8266mDNS.cpp new file mode 100644 index 000000000..62d54a7ed --- /dev/null +++ b/libraries/ESP8266mDNS/src/ESP8266mDNS.cpp @@ -0,0 +1,11 @@ +#include + +/* + * MDNS responder global instance + * + * Class type that is instantiated depends on the type mapping in ESP8266mDNS.h + */ +#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS) +MDNSResponder MDNS; +#endif + diff --git a/libraries/ESP8266mDNS/src/ESP8266mDNS.h b/libraries/ESP8266mDNS/src/ESP8266mDNS.h index e5c833d8c..2987f655c 100644 --- a/libraries/ESP8266mDNS/src/ESP8266mDNS.h +++ b/libraries/ESP8266mDNS/src/ESP8266mDNS.h @@ -45,5 +45,12 @@ #include "ESP8266mDNS_Legacy.h" #include "LEAmDNS.h" -using namespace Legacy_MDNSResponder; -//using namespace LEAmDNS; + +#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS) + // Maps the implementation to use to the global namespace type + //using MDNSResponder = Legacy_MDNSResponder::MDNSResponder; //legacy + using MDNSResponder = esp8266::MDNSImplementation::MDNSResponder; //new + + extern MDNSResponder MDNS; +#endif + diff --git a/libraries/ESP8266mDNS/src/ESP8266mDNS_Legacy.h b/libraries/ESP8266mDNS/src/ESP8266mDNS_Legacy.h index 150344b7e..6dc69048e 100644 --- a/libraries/ESP8266mDNS/src/ESP8266mDNS_Legacy.h +++ b/libraries/ESP8266mDNS/src/ESP8266mDNS_Legacy.h @@ -40,8 +40,8 @@ License (MIT license): THE SOFTWARE. */ -#ifndef ESP8266MDNS_H -#define ESP8266MDNS_H +#ifndef ESP8266MDNS_LEGACY_H +#define ESP8266MDNS_LEGACY_H #include "ESP8266WiFi.h" #include "WiFiUdp.h" @@ -139,10 +139,6 @@ private: void _restart(); }; -#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS) -extern MDNSResponder MDNS; -#endif - } // namespace Legacy_MDNSResponder #endif //ESP8266MDNS_H diff --git a/libraries/ESP8266mDNS/src/LEATimeFlag.h b/libraries/ESP8266mDNS/src/LEATimeFlag.h index a9d233fef..e0eb3b4ce 100644 --- a/libraries/ESP8266mDNS/src/LEATimeFlag.h +++ b/libraries/ESP8266mDNS/src/LEATimeFlag.h @@ -1,62 +1,60 @@ /* * LEATimeFlag.h */ -#ifndef __LEATIMEFLAG_H -#define __LEATIMEFLAG_H +#ifndef __MDNSTIMEFLAG_H +#define __MDNSTIMEFLAG_H -#include +#include +#include -/** - * clsLEATimeFlag +/* Wrapper class around PolledTimeout + * MDNS requires behavior that is slightly different from the default in PolledTimeout */ -class clsLEATimeFlag { +class clsMDNSTimeFlag { +protected: + using oneShot = esp8266::polledTimeout::oneShot; + oneShot m_clsPolledTimeout; + public: - // constructor - clsLEATimeFlag(unsigned long p_ulTimeout = (unsigned long)(-1)) - : m_ulStart(millis()), - m_ulTimeout(p_ulTimeout) { + using timeType = oneShot::timeType; + + clsMDNSTimeFlag(timeType p_Timeout) + : m_clsPolledTimeout(p_Timeout) { } - // operator bool - operator bool(void) const { + clsMDNSTimeFlag() + : m_clsPolledTimeout(std::numeric_limits::max()) { + } + + operator bool() const { return flagged(); } - // flagged - bool flagged(void) const { - return ((millis() - m_ulStart) > m_ulTimeout); + + bool flagged() const { + return m_clsPolledTimeout.checkExpired(millis()); } - // restart - void restart(unsigned long p_ulNewTimeout = (unsigned long)(-1)) { - if ((unsigned long)(-1) != p_ulNewTimeout) { - m_ulTimeout = p_ulNewTimeout; - } - m_ulStart = millis(); - } - void reset(void) { - m_ulTimeout = (unsigned long)(-1); - m_ulStart = millis(); - } - - unsigned long start(void) const { - return m_ulStart; - } - unsigned long timeout(void) const { - return m_ulTimeout; - } - bool hypotheticalTimeout(unsigned long p_ulHypotheticalTimeout) const { - return ((millis() - m_ulStart) > p_ulHypotheticalTimeout); + + void restart() { + m_clsPolledTimeout.reset(); } -protected: - unsigned long m_ulStart; - unsigned long m_ulTimeout; + void restart(const timeType p_Timeout) { + m_clsPolledTimeout.reset(p_Timeout); + } + + void reset() { + m_clsPolledTimeout.reset(std::numeric_limits::max()); + } + + timeType getTimeout() const { + return m_clsPolledTimeout.getTimeout(); + } + + bool hypotheticalTimeout(const timeType p_Timeout) const { + return m_clsPolledTimeout.checkExpired(p_Timeout); + } }; -#endif // __LEATIMEFLAG_H - - - - - +#endif // __MDNSTIMEFLAG_H diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.cpp b/libraries/ESP8266mDNS/src/LEAmDNS.cpp old mode 100755 new mode 100644 index 037d84f48..fcff320f0 --- a/libraries/ESP8266mDNS/src/LEAmDNS.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS.cpp @@ -24,10 +24,12 @@ #include "LEAmDNS_Priv.h" +namespace esp8266 { + /* * LEAmDNS */ -namespace LEAmDNS { +namespace MDNSImplementation { /** * STRINGIZE @@ -1107,14 +1109,9 @@ MDNSResponder::hMDNSService MDNSResponder::enableArduino(uint16_t p_u16Port, return hService; } -/* - * MDNS responder global instance - */ -#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS) -MDNSResponder MDNS; -#endif - -} // namespace LEAmDNS +} //namespace MDNSImplementation + +} //namespace esp8266 diff --git a/libraries/ESP8266mDNS/src/LEAmDNS.h b/libraries/ESP8266mDNS/src/LEAmDNS.h old mode 100755 new mode 100644 index 51144bd43..d017a884b --- a/libraries/ESP8266mDNS/src/LEAmDNS.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS.h @@ -99,8 +99,8 @@ * */ -#ifndef LEAMDNS_H -#define LEAMDNS_H +#ifndef MDNS_H +#define MDNS_H #include // for UdpContext.h #include "WiFiUdp.h" @@ -111,10 +111,13 @@ #include "ESP8266WiFi.h" + +namespace esp8266 { + /** * LEAmDNS */ -namespace LEAmDNS { +namespace MDNSImplementation { //this should be defined at build time #ifndef ARDUINO_BOARD @@ -455,19 +458,19 @@ protected: /** * stcMDNSServiceTxt */ - typedef struct _stcMDNSServiceTxt { - _stcMDNSServiceTxt* m_pNext; - char* m_pcKey; - char* m_pcValue; - bool m_bTemp; + struct stcMDNSServiceTxt { + stcMDNSServiceTxt* m_pNext; + char* m_pcKey; + char* m_pcValue; + bool m_bTemp; - _stcMDNSServiceTxt(const char* p_pcKey = 0, + stcMDNSServiceTxt(const char* p_pcKey = 0, const char* p_pcValue = 0, bool p_bTemp = false); - _stcMDNSServiceTxt(const _stcMDNSServiceTxt& p_Other); - ~_stcMDNSServiceTxt(void); + stcMDNSServiceTxt(const stcMDNSServiceTxt& p_Other); + ~stcMDNSServiceTxt(void); - _stcMDNSServiceTxt& operator=(const _stcMDNSServiceTxt& p_Other); + stcMDNSServiceTxt& operator=(const stcMDNSServiceTxt& p_Other); bool clear(void); char* allocKey(size_t p_stLength); @@ -489,19 +492,19 @@ protected: bool update(const char* p_pcValue); size_t length(void) const; - } stcMDNSServiceTxt; + }; /** * stcMDNSTxts */ - typedef struct _stcMDNSServiceTxts { + struct stcMDNSServiceTxts { stcMDNSServiceTxt* m_pTxts; - _stcMDNSServiceTxts(void); - _stcMDNSServiceTxts(const _stcMDNSServiceTxts& p_Other); - ~_stcMDNSServiceTxts(void); + stcMDNSServiceTxts(void); + stcMDNSServiceTxts(const stcMDNSServiceTxts& p_Other); + ~stcMDNSServiceTxts(void); - _stcMDNSServiceTxts& operator=(const _stcMDNSServiceTxts& p_Other); + stcMDNSServiceTxts& operator=(const stcMDNSServiceTxts& p_Other); bool clear(void); @@ -522,10 +525,10 @@ protected: size_t bufferLength(void) const; bool buffer(char* p_pcBuffer); - bool compare(const _stcMDNSServiceTxts& p_Other) const; - bool operator==(const _stcMDNSServiceTxts& p_Other) const; - bool operator!=(const _stcMDNSServiceTxts& p_Other) const; - } stcMDNSServiceTxts; + bool compare(const stcMDNSServiceTxts& p_Other) const; + bool operator==(const stcMDNSServiceTxts& p_Other) const; + bool operator!=(const stcMDNSServiceTxts& p_Other) const; + }; /** * enuContentFlags @@ -546,7 +549,7 @@ protected: /** * stcMDNS_MsgHeader */ - typedef struct _stcMDNS_MsgHeader { + struct stcMDNS_MsgHeader { uint16_t m_u16ID; // Identifier bool m_1bQR : 1; // Query/Response flag unsigned char m_4bOpcode : 4; // Operation code @@ -561,7 +564,7 @@ protected: uint16_t m_u16NSCount; // Authority Record count uint16_t m_u16ARCount; // Additional Record count - _stcMDNS_MsgHeader(uint16_t p_u16ID = 0, + stcMDNS_MsgHeader(uint16_t p_u16ID = 0, bool p_bQR = false, unsigned char p_ucOpcode = 0, bool p_bAA = false, @@ -573,73 +576,73 @@ protected: uint16_t p_u16ANCount = 0, uint16_t p_u16NSCount = 0, uint16_t p_u16ARCount = 0); - } stcMDNS_MsgHeader; + }; /** * stcMDNS_RRDomain */ - typedef struct _stcMDNS_RRDomain { + struct stcMDNS_RRDomain { char m_acName[MDNS_DOMAIN_MAXLENGTH]; // Encoded domain name uint16_t m_u16NameLength; // Length (incl. '\0') - _stcMDNS_RRDomain(void); - _stcMDNS_RRDomain(const _stcMDNS_RRDomain& p_Other); + stcMDNS_RRDomain(void); + stcMDNS_RRDomain(const stcMDNS_RRDomain& p_Other); - _stcMDNS_RRDomain& operator=(const _stcMDNS_RRDomain& p_Other); + stcMDNS_RRDomain& operator=(const stcMDNS_RRDomain& p_Other); bool clear(void); bool addLabel(const char* p_pcLabel, bool p_bPrependUnderline = false); - bool compare(const _stcMDNS_RRDomain& p_Other) const; - bool operator==(const _stcMDNS_RRDomain& p_Other) const; - bool operator!=(const _stcMDNS_RRDomain& p_Other) const; - bool operator>(const _stcMDNS_RRDomain& p_Other) const; + bool compare(const stcMDNS_RRDomain& p_Other) const; + bool operator==(const stcMDNS_RRDomain& p_Other) const; + bool operator!=(const stcMDNS_RRDomain& p_Other) const; + bool operator>(const stcMDNS_RRDomain& p_Other) const; size_t c_strLength(void) const; bool c_str(char* p_pcBuffer); - } stcMDNS_RRDomain; + }; /** * stcMDNS_RRAttributes */ - typedef struct _stcMDNS_RRAttributes { + struct stcMDNS_RRAttributes { uint16_t m_u16Type; // Type uint16_t m_u16Class; // Class, nearly always 'IN' - _stcMDNS_RRAttributes(uint16_t p_u16Type = 0, + stcMDNS_RRAttributes(uint16_t p_u16Type = 0, uint16_t p_u16Class = 1 /*DNS_RRCLASS_IN Internet*/); - _stcMDNS_RRAttributes(const _stcMDNS_RRAttributes& p_Other); + stcMDNS_RRAttributes(const stcMDNS_RRAttributes& p_Other); - _stcMDNS_RRAttributes& operator=(const _stcMDNS_RRAttributes& p_Other); - } stcMDNS_RRAttributes; + stcMDNS_RRAttributes& operator=(const stcMDNS_RRAttributes& p_Other); + }; /** * stcMDNS_RRHeader */ - typedef struct _stcMDNS_RRHeader { + struct stcMDNS_RRHeader { stcMDNS_RRDomain m_Domain; stcMDNS_RRAttributes m_Attributes; - _stcMDNS_RRHeader(void); - _stcMDNS_RRHeader(const _stcMDNS_RRHeader& p_Other); + stcMDNS_RRHeader(void); + stcMDNS_RRHeader(const stcMDNS_RRHeader& p_Other); - _stcMDNS_RRHeader& operator=(const _stcMDNS_RRHeader& p_Other); + stcMDNS_RRHeader& operator=(const stcMDNS_RRHeader& p_Other); bool clear(void); - } stcMDNS_RRHeader; + }; /** * stcMDNS_RRQuestion */ - typedef struct _stcMDNS_RRQuestion { - _stcMDNS_RRQuestion* m_pNext; - _stcMDNS_RRHeader m_Header; + struct stcMDNS_RRQuestion { + stcMDNS_RRQuestion* m_pNext; + stcMDNS_RRHeader m_Header; bool m_bUnicast; // Unicast reply requested - _stcMDNS_RRQuestion(void); - } stcMDNS_RRQuestion; + stcMDNS_RRQuestion(void); + }; /** * enuAnswerType @@ -656,110 +659,110 @@ protected: /** * stcMDNS_RRAnswer */ - typedef struct _stcMDNS_RRAnswer { - _stcMDNS_RRAnswer* m_pNext; + struct stcMDNS_RRAnswer { + stcMDNS_RRAnswer* m_pNext; const enuAnswerType m_AnswerType; - _stcMDNS_RRHeader m_Header; + stcMDNS_RRHeader m_Header; bool m_bCacheFlush; // Cache flush command bit uint32_t m_u32TTL; // Validity time in seconds - virtual ~_stcMDNS_RRAnswer(void); + virtual ~stcMDNS_RRAnswer(void); enuAnswerType answerType(void) const; bool clear(void); protected: - _stcMDNS_RRAnswer(enuAnswerType p_AnswerType, + stcMDNS_RRAnswer(enuAnswerType p_AnswerType, const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL); - } stcMDNS_RRAnswer; + }; #ifdef MDNS_IP4_SUPPORT /** * stcMDNS_RRAnswerA */ - typedef struct _stcMDNS_RRAnswerA : public stcMDNS_RRAnswer { + struct stcMDNS_RRAnswerA : public stcMDNS_RRAnswer { IPAddress m_IPAddress; - _stcMDNS_RRAnswerA(const stcMDNS_RRHeader& p_Header, + stcMDNS_RRAnswerA(const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL); - ~_stcMDNS_RRAnswerA(void); + ~stcMDNS_RRAnswerA(void); bool clear(void); - } stcMDNS_RRAnswerA; + }; #endif /** * stcMDNS_RRAnswerPTR */ - typedef struct _stcMDNS_RRAnswerPTR : public stcMDNS_RRAnswer { + struct stcMDNS_RRAnswerPTR : public stcMDNS_RRAnswer { stcMDNS_RRDomain m_PTRDomain; - _stcMDNS_RRAnswerPTR(const stcMDNS_RRHeader& p_Header, + stcMDNS_RRAnswerPTR(const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL); - ~_stcMDNS_RRAnswerPTR(void); + ~stcMDNS_RRAnswerPTR(void); bool clear(void); - } stcMDNS_RRAnswerPTR; + }; /** * stcMDNS_RRAnswerTXT */ - typedef struct _stcMDNS_RRAnswerTXT : public stcMDNS_RRAnswer { + struct stcMDNS_RRAnswerTXT : public stcMDNS_RRAnswer { stcMDNSServiceTxts m_Txts; - _stcMDNS_RRAnswerTXT(const stcMDNS_RRHeader& p_Header, + stcMDNS_RRAnswerTXT(const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL); - ~_stcMDNS_RRAnswerTXT(void); + ~stcMDNS_RRAnswerTXT(void); bool clear(void); - } stcMDNS_RRAnswerTXT; + }; #ifdef MDNS_IP6_SUPPORT /** * stcMDNS_RRAnswerAAAA */ - typedef struct _stcMDNS_RRAnswerAAAA : public stcMDNS_RRAnswer { + struct stcMDNS_RRAnswerAAAA : public stcMDNS_RRAnswer { //TODO: IP6Address m_IPAddress; - _stcMDNS_RRAnswerAAAA(const stcMDNS_RRHeader& p_Header, + stcMDNS_RRAnswerAAAA(const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL); - ~_stcMDNS_RRAnswerAAAA(void); + ~stcMDNS_RRAnswerAAAA(void); bool clear(void); - } stcMDNS_RRAnswerAAAA; + }; #endif /** * stcMDNS_RRAnswerSRV */ - typedef struct _stcMDNS_RRAnswerSRV : public stcMDNS_RRAnswer { + struct stcMDNS_RRAnswerSRV : public stcMDNS_RRAnswer { uint16_t m_u16Priority; uint16_t m_u16Weight; uint16_t m_u16Port; stcMDNS_RRDomain m_SRVDomain; - _stcMDNS_RRAnswerSRV(const stcMDNS_RRHeader& p_Header, + stcMDNS_RRAnswerSRV(const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL); - ~_stcMDNS_RRAnswerSRV(void); + ~stcMDNS_RRAnswerSRV(void); bool clear(void); - } stcMDNS_RRAnswerSRV; + }; /** * stcMDNS_RRAnswerGeneric */ - typedef struct _stcMDNS_RRAnswerGeneric : public stcMDNS_RRAnswer { + struct stcMDNS_RRAnswerGeneric : public stcMDNS_RRAnswer { uint16_t m_u16RDLength; // Length of variable answer uint8_t* m_pu8RDData; // Offset of start of variable answer in packet - _stcMDNS_RRAnswerGeneric(const stcMDNS_RRHeader& p_Header, + stcMDNS_RRAnswerGeneric(const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL); - ~_stcMDNS_RRAnswerGeneric(void); + ~stcMDNS_RRAnswerGeneric(void); bool clear(void); - } stcMDNS_RRAnswerGeneric; + }; /** @@ -775,26 +778,26 @@ protected: /** * stcProbeInformation */ - typedef struct _stcProbeInformation { + struct stcProbeInformation { enuProbingStatus m_ProbingStatus; uint8_t m_u8ProbesSent; - clsLEATimeFlag m_NextProbeTimeFlag; + clsMDNSTimeFlag m_NextProbeTimeFlag; bool m_bConflict; bool m_bTiebreakNeeded; MDNSProbeResultCallbackFn m_fnProbeResultCallback; void* m_pProbeResultCallbackUserdata; - _stcProbeInformation(void); + stcProbeInformation(void); bool clear(bool p_bClearUserdata = false); - } stcProbeInformation; + }; /** * stcMDNSService */ - typedef struct _stcMDNSService { - _stcMDNSService* m_pNext; + struct stcMDNSService { + stcMDNSService* m_pNext; char* m_pcName; bool m_bAutoName; // Name was set automatically to hostname (if no name was supplied) char* m_pcService; @@ -806,10 +809,10 @@ protected: void* m_pTxtCallbackUserdata; stcProbeInformation m_ProbeInformation; - _stcMDNSService(const char* p_pcName = 0, + stcMDNSService(const char* p_pcName = 0, const char* p_pcService = 0, const char* p_pcProtocol = 0); - ~_stcMDNSService(void); + ~stcMDNSService(void); bool setName(const char* p_pcName); bool releaseName(void); @@ -819,54 +822,54 @@ protected: bool setProtocol(const char* p_pcProtocol); bool releaseProtocol(void); - } stcMDNSService; + }; /** * stcMDNSServiceQuery */ - typedef struct _stcMDNSServiceQuery { + struct stcMDNSServiceQuery { /** * stcAnswer */ - typedef struct _stcAnswer { + struct stcAnswer { /** * stcTTL */ - typedef struct _stcTTL { - clsLEATimeFlag m_TTLTimeFlag; + struct stcTTL { + clsMDNSTimeFlag m_TTLTimeFlag; bool m_bUpdateScheduled; - _stcTTL(uint32_t p_u32TTL = 0); + stcTTL(uint32_t p_u32TTL = 0); bool set(uint32_t p_u32TTL); bool has80Percent(void) const; bool isOutdated(void) const; - } stcTTL; + }; #ifdef MDNS_IP4_SUPPORT /** * stcIP4Address */ - typedef struct _stcIP4Address { - _stcIP4Address* m_pNext; + struct stcIP4Address { + stcIP4Address* m_pNext; IPAddress m_IPAddress; stcTTL m_TTL; - _stcIP4Address(IPAddress p_IPAddress, + stcIP4Address(IPAddress p_IPAddress, uint32_t p_u32TTL = 0); - } stcIP4Address; + }; #endif #ifdef MDNS_IP6_SUPPORT /** * stcIP6Address */ - typedef struct _stcIP6Address { - _stcIP6Address* m_pNext; + struct stcIP6Address { + stcIP6Address* m_pNext; IP6Address m_IPAddress; stcTTL m_TTL; - } stcIP6Address; + }; #endif - _stcAnswer* m_pNext; + stcAnswer* m_pNext; // The service domain is the first 'answer' (from PTR answer, using service and protocol) to be set // Defines the key for additional answer, like host domain, etc. stcMDNS_RRDomain m_ServiceDomain; // 1. level answer (PTR), eg. MyESP._http._tcp.local @@ -887,8 +890,8 @@ protected: #endif uint32_t m_u32ContentFlags; - _stcAnswer(void); - ~_stcAnswer(void); + stcAnswer(void); + ~stcAnswer(void); bool clear(void); @@ -903,8 +906,8 @@ protected: #ifdef MDNS_IP4_SUPPORT bool releaseIP4Addresses(void); - bool addIP4Address(_stcIP4Address* p_pIP4Address); - bool removeIP4Address(_stcIP4Address* p_pIP4Address); + bool addIP4Address(stcIP4Address* p_pIP4Address); + bool removeIP4Address(stcIP4Address* p_pIP4Address); const stcIP4Address* findIP4Address(const IPAddress& p_IPAddress) const; stcIP4Address* findIP4Address(const IPAddress& p_IPAddress); uint32_t IP4AddressCount(void) const; @@ -913,17 +916,17 @@ protected: #endif #ifdef MDNS_IP6_SUPPORT bool releaseIP6Addresses(void); - bool addIP6Address(_stcIP6Address* p_pIP6Address); - bool removeIP6Address(_stcIP6Address* p_pIP6Address); + bool addIP6Address(stcIP6Address* p_pIP6Address); + bool removeIP6Address(stcIP6Address* p_pIP6Address); const stcIP6Address* findIP6Address(const IPAddress& p_IPAddress) const; stcIP6Address* findIP6Address(const IPAddress& p_IPAddress); uint32_t IP6AddressCount(void) const; const stcIP6Address* IP6AddressAtIndex(uint32_t p_u32Index) const; stcIP6Address* IP6AddressAtIndex(uint32_t p_u32Index); #endif - } stcAnswer; + }; - _stcMDNSServiceQuery* m_pNext; + stcMDNSServiceQuery* m_pNext; stcMDNS_RRDomain m_ServiceTypeDomain; // eg. _http._tcp.local MDNSServiceQueryCallbackFn m_fnCallback; void* m_pUserdata; @@ -931,8 +934,8 @@ protected: bool m_bAwaitingAnswers; stcAnswer* m_pAnswers; - _stcMDNSServiceQuery(void); - ~_stcMDNSServiceQuery(void); + stcMDNSServiceQuery(void); + ~stcMDNSServiceQuery(void); bool clear(void); @@ -946,26 +949,26 @@ protected: stcAnswer* findAnswerForServiceDomain(const stcMDNS_RRDomain& p_ServiceDomain); stcAnswer* findAnswerForHostDomain(const stcMDNS_RRDomain& p_HostDomain); - } stcMDNSServiceQuery; + }; /** * stcMDNSSendParameter */ - typedef struct _stcMDNSSendParameter { + struct stcMDNSSendParameter { protected: /** * stcDomainCacheItem */ - typedef struct _stcDomainCacheItem { - _stcDomainCacheItem* m_pNext; + struct stcDomainCacheItem { + stcDomainCacheItem* m_pNext; const void* m_pHostnameOrService; // Opaque id for host or service domain (pointer) bool m_bAdditionalData; // Opaque flag for special info (service domain included) uint16_t m_u16Offset; // Offset in UDP output buffer - _stcDomainCacheItem(const void* p_pHostnameOrService, - bool p_bAdditionalData, - uint32_t p_u16Offset); - } stcDomainCacheItem; + stcDomainCacheItem(const void* p_pHostnameOrService, + bool p_bAdditionalData, + uint32_t p_u16Offset); + }; public: uint16_t m_u16ID; // Query ID (used only in lagacy queries) @@ -980,8 +983,8 @@ protected: uint16_t m_u16Offset; // Current offset in UDP write buffer (mainly for domain cache) stcDomainCacheItem* m_pDomainCacheItems; // Cached host and service domains - _stcMDNSSendParameter(void); - ~_stcMDNSSendParameter(void); + stcMDNSSendParameter(void); + ~stcMDNSSendParameter(void); bool clear(void); @@ -992,7 +995,7 @@ protected: uint16_t p_u16Offset); uint16_t findCachedDomainOffset(const void* p_pHostnameOrService, bool p_bAdditionalData) const; - } stcMDNSSendParameter; + }; // Instance variables stcMDNSService* m_pServices; @@ -1247,17 +1250,8 @@ protected: #endif }; -#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS) - extern MDNSResponder MDNS; -#endif - -} // namespace LEAmDNS - -#endif // LEAMDNS_H - - - - - +}// namespace MDNSImplementation +}// namespace esp8266 +#endif // MDNS_H diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp old mode 100755 new mode 100644 index 98bd6f32d..5a95a0ec2 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp @@ -41,11 +41,11 @@ extern "C" { #include "LEAmDNS_lwIPdefs.h" #include "LEAmDNS_Priv.h" - +namespace esp8266 { /* - * namespace LEAmDNS + * LEAmDNS */ -namespace LEAmDNS { +namespace MDNSImplementation { /** * CONTROL @@ -1056,6 +1056,7 @@ bool MDNSResponder::_updateProbeStatus(void) { // // Probe host domain if ((ProbingStatus_ReadyToStart == m_HostProbeInformation.m_ProbingStatus) && // Ready to get started AND + //TODO: Fix the following to allow Ethernet shield or other interfaces (_getResponseMulticastInterface(SOFTAP_MODE | STATION_MODE) != IPAddress())) { // Has IP address DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR_LEA("[MDNSResponder] _updateProbeStatus: Starting host probing...\n"));); @@ -1750,7 +1751,6 @@ uint8_t MDNSResponder::_replyMaskForService(const MDNSResponder::stcMDNS_RRHeade return u8ReplyMask; } -} // namespace LEAmDNS - - +} // namespace MDNSImplementation +} // namespace esp8266 diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp old mode 100755 new mode 100644 index 31cf21be0..f6061b051 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp @@ -27,14 +27,8 @@ #include "LEAmDNS_lwIPdefs.h" #include "LEAmDNS_Priv.h" -/* - * namespace LEAmDNS - */ -namespace LEAmDNS { -/** - * HELPERS - */ +namespace { /* * strrstr (static) @@ -43,7 +37,7 @@ namespace LEAmDNS { * Based on: https://stackoverflow.com/a/1634398/2778898 * */ -static const char* strrstr(const char*__restrict p_pcString, const char*__restrict p_pcPattern) { +const char* strrstr(const char*__restrict p_pcString, const char*__restrict p_pcPattern) { const char* pcResult = 0; @@ -65,6 +59,24 @@ static const char* strrstr(const char*__restrict p_pcString, const char*__restri return pcResult; } + +} // anonymous + + + + + +namespace esp8266 { + +/* + * LEAmDNS + */ +namespace MDNSImplementation { + +/** + * HELPERS + */ + /* * MDNSResponder::indexDomain (static) * @@ -722,7 +734,9 @@ bool MDNSResponder::_releaseTempServiceTxts(MDNSResponder::stcMDNSService& p_rSe } #endif -} // namespace LEAmDNS +} // namespace MDNSImplementation + +} // namespace esp8266 diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Priv.h b/libraries/ESP8266mDNS/src/LEAmDNS_Priv.h old mode 100755 new mode 100644 index 1c2294e4d..36c2b77f9 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Priv.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Priv.h @@ -22,13 +22,16 @@ * */ -#ifndef LEAMDNS_PRIV_H -#define LEAMDNS_PRIV_H +#ifndef MDNS_PRIV_H +#define MDNS_PRIV_H + +namespace esp8266 { /* - * namespace LEAmDNS + * LEAmDNS */ -namespace LEAmDNS { + +namespace MDNSImplementation { // Enable class debug functions #define ESP_8266_MDNS_INCLUDE @@ -153,16 +156,12 @@ namespace LEAmDNS { #define F(A) A #endif -} // namespace LEAmDNS +} // namespace MDNSImplementation +} // namespace esp8266 // Include the main header, so the submodlues only need to include this header #include "LEAmDNS.h" -#endif // LEAMDNS_PRIV_H - - - - - +#endif // MDNS_PRIV_H diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp old mode 100755 new mode 100644 index 9898e8cb7..c8ceeb62a --- a/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp @@ -25,10 +25,12 @@ #include "LEAmDNS_Priv.h" #include "LEAmDNS_lwIPdefs.h" +namespace esp8266 { + /* - * namespace LEAmDNS + * LEAmDNS */ -namespace LEAmDNS { +namespace MDNSImplementation { /** * STRUCTS @@ -45,9 +47,9 @@ namespace LEAmDNS { */ /* - * MDNSResponder::stcMDNSServiceTxt::_stcMDNSServiceTxt constructor + * MDNSResponder::stcMDNSServiceTxt::stcMDNSServiceTxt constructor */ -MDNSResponder::_stcMDNSServiceTxt::_stcMDNSServiceTxt(const char* p_pcKey /*= 0*/, +MDNSResponder::stcMDNSServiceTxt::stcMDNSServiceTxt(const char* p_pcKey /*= 0*/, const char* p_pcValue /*= 0*/, bool p_bTemp /*= false*/) : m_pNext(0), @@ -60,9 +62,9 @@ MDNSResponder::_stcMDNSServiceTxt::_stcMDNSServiceTxt(const char* p_pcKey /*= 0* } /* - * MDNSResponder::_stcMDNSServiceTxt::_stcMDNSServiceTxt copy-constructor + * MDNSResponder::stcMDNSServiceTxt::stcMDNSServiceTxt copy-constructor */ -MDNSResponder::_stcMDNSServiceTxt::_stcMDNSServiceTxt(const MDNSResponder::_stcMDNSServiceTxt& p_Other) +MDNSResponder::stcMDNSServiceTxt::stcMDNSServiceTxt(const MDNSResponder::stcMDNSServiceTxt& p_Other) : m_pNext(0), m_pcKey(0), m_pcValue(0), @@ -72,17 +74,17 @@ MDNSResponder::_stcMDNSServiceTxt::_stcMDNSServiceTxt(const MDNSResponder::_stcM } /* - * MDNSResponder::_stcMDNSServiceTxt::~_stcMDNSServiceTxt destructor + * MDNSResponder::stcMDNSServiceTxt::~stcMDNSServiceTxt destructor */ -MDNSResponder::_stcMDNSServiceTxt::~_stcMDNSServiceTxt(void) { +MDNSResponder::stcMDNSServiceTxt::~stcMDNSServiceTxt(void) { clear(); } /* - * MDNSResponder::_stcMDNSServiceTxt::operator= + * MDNSResponder::stcMDNSServiceTxt::operator= */ -MDNSResponder::_stcMDNSServiceTxt& MDNSResponder::_stcMDNSServiceTxt::operator=(const MDNSResponder::_stcMDNSServiceTxt& p_Other) { +MDNSResponder::stcMDNSServiceTxt& MDNSResponder::stcMDNSServiceTxt::operator=(const MDNSResponder::stcMDNSServiceTxt& p_Other) { if (&p_Other != this) { clear(); @@ -92,9 +94,9 @@ MDNSResponder::_stcMDNSServiceTxt& MDNSResponder::_stcMDNSServiceTxt::operator=( } /* - * MDNSResponder::_stcMDNSServiceTxt::clear + * MDNSResponder::stcMDNSServiceTxt::clear */ -bool MDNSResponder::_stcMDNSServiceTxt::clear(void) { +bool MDNSResponder::stcMDNSServiceTxt::clear(void) { releaseKey(); releaseValue(); @@ -102,9 +104,9 @@ bool MDNSResponder::_stcMDNSServiceTxt::clear(void) { } /* - * MDNSResponder::_stcMDNSServiceTxt::allocKey + * MDNSResponder::stcMDNSServiceTxt::allocKey */ -char* MDNSResponder::_stcMDNSServiceTxt::allocKey(size_t p_stLength) { +char* MDNSResponder::stcMDNSServiceTxt::allocKey(size_t p_stLength) { releaseKey(); if (p_stLength) { @@ -114,9 +116,9 @@ char* MDNSResponder::_stcMDNSServiceTxt::allocKey(size_t p_stLength) { } /* - * MDNSResponder::_stcMDNSServiceTxt::setKey + * MDNSResponder::stcMDNSServiceTxt::setKey */ -bool MDNSResponder::_stcMDNSServiceTxt::setKey(const char* p_pcKey, +bool MDNSResponder::stcMDNSServiceTxt::setKey(const char* p_pcKey, size_t p_stLength) { bool bResult = false; @@ -133,17 +135,17 @@ bool MDNSResponder::_stcMDNSServiceTxt::setKey(const char* p_pcKey, } /* - * MDNSResponder::_stcMDNSServiceTxt::setKey + * MDNSResponder::stcMDNSServiceTxt::setKey */ -bool MDNSResponder::_stcMDNSServiceTxt::setKey(const char* p_pcKey) { +bool MDNSResponder::stcMDNSServiceTxt::setKey(const char* p_pcKey) { return setKey(p_pcKey, (p_pcKey ? os_strlen(p_pcKey) : 0)); } /* - * MDNSResponder::_stcMDNSServiceTxt::releaseKey + * MDNSResponder::stcMDNSServiceTxt::releaseKey */ -bool MDNSResponder::_stcMDNSServiceTxt::releaseKey(void) { +bool MDNSResponder::stcMDNSServiceTxt::releaseKey(void) { if (m_pcKey) { delete[] m_pcKey; @@ -153,9 +155,9 @@ bool MDNSResponder::_stcMDNSServiceTxt::releaseKey(void) { } /* - * MDNSResponder::_stcMDNSServiceTxt::allocValue + * MDNSResponder::stcMDNSServiceTxt::allocValue */ -char* MDNSResponder::_stcMDNSServiceTxt::allocValue(size_t p_stLength) { +char* MDNSResponder::stcMDNSServiceTxt::allocValue(size_t p_stLength) { releaseValue(); if (p_stLength) { @@ -165,9 +167,9 @@ char* MDNSResponder::_stcMDNSServiceTxt::allocValue(size_t p_stLength) { } /* - * MDNSResponder::_stcMDNSServiceTxt::setValue + * MDNSResponder::stcMDNSServiceTxt::setValue */ -bool MDNSResponder::_stcMDNSServiceTxt::setValue(const char* p_pcValue, +bool MDNSResponder::stcMDNSServiceTxt::setValue(const char* p_pcValue, size_t p_stLength) { bool bResult = false; @@ -187,17 +189,17 @@ bool MDNSResponder::_stcMDNSServiceTxt::setValue(const char* p_pcValue, } /* - * MDNSResponder::_stcMDNSServiceTxt::setValue + * MDNSResponder::stcMDNSServiceTxt::setValue */ -bool MDNSResponder::_stcMDNSServiceTxt::setValue(const char* p_pcValue) { +bool MDNSResponder::stcMDNSServiceTxt::setValue(const char* p_pcValue) { return setValue(p_pcValue, (p_pcValue ? os_strlen(p_pcValue) : 0)); } /* - * MDNSResponder::_stcMDNSServiceTxt::releaseValue + * MDNSResponder::stcMDNSServiceTxt::releaseValue */ -bool MDNSResponder::_stcMDNSServiceTxt::releaseValue(void) { +bool MDNSResponder::stcMDNSServiceTxt::releaseValue(void) { if (m_pcValue) { delete[] m_pcValue; @@ -207,9 +209,9 @@ bool MDNSResponder::_stcMDNSServiceTxt::releaseValue(void) { } /* - * MDNSResponder::_stcMDNSServiceTxt::set + * MDNSResponder::stcMDNSServiceTxt::set */ -bool MDNSResponder::_stcMDNSServiceTxt::set(const char* p_pcKey, +bool MDNSResponder::stcMDNSServiceTxt::set(const char* p_pcKey, const char* p_pcValue, bool p_bTemp /*= false*/) { @@ -219,19 +221,19 @@ bool MDNSResponder::_stcMDNSServiceTxt::set(const char* p_pcKey, } /* - * MDNSResponder::_stcMDNSServiceTxt::update + * MDNSResponder::stcMDNSServiceTxt::update */ -bool MDNSResponder::_stcMDNSServiceTxt::update(const char* p_pcValue) { +bool MDNSResponder::stcMDNSServiceTxt::update(const char* p_pcValue) { return setValue(p_pcValue); } /* - * MDNSResponder::_stcMDNSServiceTxt::length + * MDNSResponder::stcMDNSServiceTxt::length * * length of eg. 'c#=1' without any closing '\0' */ -size_t MDNSResponder::_stcMDNSServiceTxt::length(void) const { +size_t MDNSResponder::stcMDNSServiceTxt::length(void) const { size_t stLength = 0; if (m_pcKey) { @@ -256,34 +258,34 @@ size_t MDNSResponder::_stcMDNSServiceTxt::length(void) const { */ /* - * MDNSResponder::_stcMDNSServiceTxts::_stcMDNSServiceTxts contructor + * MDNSResponder::stcMDNSServiceTxts::stcMDNSServiceTxts contructor */ -MDNSResponder::_stcMDNSServiceTxts::_stcMDNSServiceTxts(void) +MDNSResponder::stcMDNSServiceTxts::stcMDNSServiceTxts(void) : m_pTxts(0) { } /* - * MDNSResponder::_stcMDNSServiceTxts::_stcMDNSServiceTxts copy-constructor + * MDNSResponder::stcMDNSServiceTxts::stcMDNSServiceTxts copy-constructor */ -MDNSResponder::_stcMDNSServiceTxts::_stcMDNSServiceTxts(const _stcMDNSServiceTxts& p_Other) +MDNSResponder::stcMDNSServiceTxts::stcMDNSServiceTxts(const stcMDNSServiceTxts& p_Other) : m_pTxts(0) { operator=(p_Other); } /* - * MDNSResponder::_stcMDNSServiceTxts::~_stcMDNSServiceTxts destructor + * MDNSResponder::stcMDNSServiceTxts::~stcMDNSServiceTxts destructor */ -MDNSResponder::_stcMDNSServiceTxts::~_stcMDNSServiceTxts(void) { +MDNSResponder::stcMDNSServiceTxts::~stcMDNSServiceTxts(void) { clear(); } /* - * MDNSResponder::_stcMDNSServiceTxts::operator= + * MDNSResponder::stcMDNSServiceTxts::operator= */ -MDNSResponder::_stcMDNSServiceTxts& MDNSResponder::_stcMDNSServiceTxts::operator=(const _stcMDNSServiceTxts& p_Other) { +MDNSResponder::stcMDNSServiceTxts& MDNSResponder::stcMDNSServiceTxts::operator=(const stcMDNSServiceTxts& p_Other) { if (this != &p_Other) { clear(); @@ -296,9 +298,9 @@ MDNSResponder::_stcMDNSServiceTxts& MDNSResponder::_stcMDNSServiceTxts::operator } /* - * MDNSResponder::_stcMDNSServiceTxts::clear + * MDNSResponder::stcMDNSServiceTxts::clear */ -bool MDNSResponder::_stcMDNSServiceTxts::clear(void) { +bool MDNSResponder::stcMDNSServiceTxts::clear(void) { while (m_pTxts) { stcMDNSServiceTxt* pNext = m_pTxts->m_pNext; @@ -309,9 +311,9 @@ bool MDNSResponder::_stcMDNSServiceTxts::clear(void) { } /* - * MDNSResponder::_stcMDNSServiceTxts::add + * MDNSResponder::stcMDNSServiceTxts::add */ -bool MDNSResponder::_stcMDNSServiceTxts::add(MDNSResponder::stcMDNSServiceTxt* p_pTxt) { +bool MDNSResponder::stcMDNSServiceTxts::add(MDNSResponder::stcMDNSServiceTxt* p_pTxt) { bool bResult = false; @@ -324,9 +326,9 @@ bool MDNSResponder::_stcMDNSServiceTxts::add(MDNSResponder::stcMDNSServiceTxt* p } /* - * MDNSResponder::_stcMDNSServiceTxts::remove + * MDNSResponder::stcMDNSServiceTxts::remove */ -bool MDNSResponder::_stcMDNSServiceTxts::remove(stcMDNSServiceTxt* p_pTxt) { +bool MDNSResponder::stcMDNSServiceTxts::remove(stcMDNSServiceTxt* p_pTxt) { bool bResult = false; @@ -351,9 +353,9 @@ bool MDNSResponder::_stcMDNSServiceTxts::remove(stcMDNSServiceTxt* p_pTxt) { } /* - * MDNSResponder::_stcMDNSServiceTxts::removeTempTxts + * MDNSResponder::stcMDNSServiceTxts::removeTempTxts */ -bool MDNSResponder::_stcMDNSServiceTxts::removeTempTxts(void) { +bool MDNSResponder::stcMDNSServiceTxts::removeTempTxts(void) { bool bResult = true; @@ -370,11 +372,11 @@ bool MDNSResponder::_stcMDNSServiceTxts::removeTempTxts(void) { } /* - * MDNSResponder::_stcMDNSServiceTxts::find + * MDNSResponder::stcMDNSServiceTxts::find */ -MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_stcMDNSServiceTxts::find(const char* p_pcKey) { +MDNSResponder::stcMDNSServiceTxt* MDNSResponder::stcMDNSServiceTxts::find(const char* p_pcKey) { - _stcMDNSServiceTxt* pResult = 0; + stcMDNSServiceTxt* pResult = 0; for (stcMDNSServiceTxt* pTxt=m_pTxts; pTxt; pTxt=pTxt->m_pNext) { if ((p_pcKey) && @@ -387,11 +389,11 @@ MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_stcMDNSServiceTxts::find(const } /* - * MDNSResponder::_stcMDNSServiceTxts::find + * MDNSResponder::stcMDNSServiceTxts::find */ -const MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_stcMDNSServiceTxts::find(const char* p_pcKey) const { +const MDNSResponder::stcMDNSServiceTxt* MDNSResponder::stcMDNSServiceTxts::find(const char* p_pcKey) const { - const _stcMDNSServiceTxt* pResult = 0; + const stcMDNSServiceTxt* pResult = 0; for (const stcMDNSServiceTxt* pTxt=m_pTxts; pTxt; pTxt=pTxt->m_pNext) { if ((p_pcKey) && @@ -405,11 +407,11 @@ const MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_stcMDNSServiceTxts::find } /* - * MDNSResponder::_stcMDNSServiceTxts::find + * MDNSResponder::stcMDNSServiceTxts::find */ -MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_stcMDNSServiceTxts::find(const stcMDNSServiceTxt* p_pTxt) { +MDNSResponder::stcMDNSServiceTxt* MDNSResponder::stcMDNSServiceTxts::find(const stcMDNSServiceTxt* p_pTxt) { - _stcMDNSServiceTxt* pResult = 0; + stcMDNSServiceTxt* pResult = 0; for (stcMDNSServiceTxt* pTxt=m_pTxts; pTxt; pTxt=pTxt->m_pNext) { if (p_pTxt == pTxt) { @@ -421,9 +423,9 @@ MDNSResponder::stcMDNSServiceTxt* MDNSResponder::_stcMDNSServiceTxts::find(const } /* - * MDNSResponder::_stcMDNSServiceTxts::length + * MDNSResponder::stcMDNSServiceTxts::length */ -uint16_t MDNSResponder::_stcMDNSServiceTxts::length(void) const { +uint16_t MDNSResponder::stcMDNSServiceTxts::length(void) const { uint16_t u16Length = 0; @@ -437,19 +439,19 @@ uint16_t MDNSResponder::_stcMDNSServiceTxts::length(void) const { } /* - * MDNSResponder::_stcMDNSServiceTxts::c_strLength + * MDNSResponder::stcMDNSServiceTxts::c_strLength * * (incl. closing '\0'). Length bytes place is used for delimiting ';' and closing '\0' */ -size_t MDNSResponder::_stcMDNSServiceTxts::c_strLength(void) const { +size_t MDNSResponder::stcMDNSServiceTxts::c_strLength(void) const { return length(); } /* - * MDNSResponder::_stcMDNSServiceTxts::c_str + * MDNSResponder::stcMDNSServiceTxts::c_str */ -bool MDNSResponder::_stcMDNSServiceTxts::c_str(char* p_pcBuffer) { +bool MDNSResponder::stcMDNSServiceTxts::c_str(char* p_pcBuffer) { bool bResult = false; @@ -478,19 +480,19 @@ bool MDNSResponder::_stcMDNSServiceTxts::c_str(char* p_pcBuffer) { } /* - * MDNSResponder::_stcMDNSServiceTxts::bufferLength + * MDNSResponder::stcMDNSServiceTxts::bufferLength * * (incl. closing '\0'). */ -size_t MDNSResponder::_stcMDNSServiceTxts::bufferLength(void) const { +size_t MDNSResponder::stcMDNSServiceTxts::bufferLength(void) const { return (length() + 1); } /* - * MDNSResponder::_stcMDNSServiceTxts::toBuffer + * MDNSResponder::stcMDNSServiceTxts::toBuffer */ -bool MDNSResponder::_stcMDNSServiceTxts::buffer(char* p_pcBuffer) { +bool MDNSResponder::stcMDNSServiceTxts::buffer(char* p_pcBuffer) { bool bResult = false; @@ -517,9 +519,9 @@ bool MDNSResponder::_stcMDNSServiceTxts::buffer(char* p_pcBuffer) { } /* - * MDNSResponder::_stcMDNSServiceTxts::compare + * MDNSResponder::stcMDNSServiceTxts::compare */ -bool MDNSResponder::_stcMDNSServiceTxts::compare(const MDNSResponder::_stcMDNSServiceTxts& p_Other) const { +bool MDNSResponder::stcMDNSServiceTxts::compare(const MDNSResponder::stcMDNSServiceTxts& p_Other) const { bool bResult = false; @@ -547,17 +549,17 @@ bool MDNSResponder::_stcMDNSServiceTxts::compare(const MDNSResponder::_stcMDNSSe } /* - * MDNSResponder::_stcMDNSServiceTxts::operator== + * MDNSResponder::stcMDNSServiceTxts::operator== */ -bool MDNSResponder::_stcMDNSServiceTxts::operator==(const _stcMDNSServiceTxts& p_Other) const { +bool MDNSResponder::stcMDNSServiceTxts::operator==(const stcMDNSServiceTxts& p_Other) const { return compare(p_Other); } /* - * MDNSResponder::_stcMDNSServiceTxts::operator!= + * MDNSResponder::stcMDNSServiceTxts::operator!= */ -bool MDNSResponder::_stcMDNSServiceTxts::operator!=(const _stcMDNSServiceTxts& p_Other) const { +bool MDNSResponder::stcMDNSServiceTxts::operator!=(const stcMDNSServiceTxts& p_Other) const { return !compare(p_Other); } @@ -571,9 +573,9 @@ bool MDNSResponder::_stcMDNSServiceTxts::operator!=(const _stcMDNSServiceTxts& p */ /* - * MDNSResponder::_stcMDNS_MsgHeader::_stcMDNS_MsgHeader + * MDNSResponder::stcMDNS_MsgHeader::stcMDNS_MsgHeader */ -MDNSResponder::_stcMDNS_MsgHeader::_stcMDNS_MsgHeader(uint16_t p_u16ID /*= 0*/, +MDNSResponder::stcMDNS_MsgHeader::stcMDNS_MsgHeader(uint16_t p_u16ID /*= 0*/, bool p_bQR /*= false*/, unsigned char p_ucOpcode /*= 0*/, bool p_bAA /*= false*/, @@ -610,27 +612,27 @@ MDNSResponder::_stcMDNS_MsgHeader::_stcMDNS_MsgHeader(uint16_t p_u16ID /*= 0*/, */ /* - * MDNSResponder::_stcMDNS_RRDomain::_stcMDNS_RRDomain constructor + * MDNSResponder::stcMDNS_RRDomain::stcMDNS_RRDomain constructor */ -MDNSResponder::_stcMDNS_RRDomain::_stcMDNS_RRDomain(void) +MDNSResponder::stcMDNS_RRDomain::stcMDNS_RRDomain(void) : m_u16NameLength(0) { clear(); } /* - * MDNSResponder::_stcMDNS_RRDomain::_stcMDNS_RRDomain copy-constructor + * MDNSResponder::stcMDNS_RRDomain::stcMDNS_RRDomain copy-constructor */ -MDNSResponder::_stcMDNS_RRDomain::_stcMDNS_RRDomain(const _stcMDNS_RRDomain& p_Other) +MDNSResponder::stcMDNS_RRDomain::stcMDNS_RRDomain(const stcMDNS_RRDomain& p_Other) : m_u16NameLength(0) { operator=(p_Other); } /* - * MDNSResponder::_stcMDNS_RRDomain::operator = + * MDNSResponder::stcMDNS_RRDomain::operator = */ -MDNSResponder::_stcMDNS_RRDomain& MDNSResponder::_stcMDNS_RRDomain::operator=(const _stcMDNS_RRDomain& p_Other) { +MDNSResponder::stcMDNS_RRDomain& MDNSResponder::stcMDNS_RRDomain::operator=(const stcMDNS_RRDomain& p_Other) { if (&p_Other != this) { memcpy(m_acName, p_Other.m_acName, sizeof(m_acName)); @@ -640,9 +642,9 @@ MDNSResponder::_stcMDNS_RRDomain& MDNSResponder::_stcMDNS_RRDomain::operator=(co } /* - * MDNSResponder::_stcMDNS_RRDomain::clear + * MDNSResponder::stcMDNS_RRDomain::clear */ -bool MDNSResponder::_stcMDNS_RRDomain::clear(void) { +bool MDNSResponder::stcMDNS_RRDomain::clear(void) { memset(m_acName, 0, sizeof(m_acName)); m_u16NameLength = 0; @@ -650,9 +652,9 @@ bool MDNSResponder::_stcMDNS_RRDomain::clear(void) { } /* - * MDNSResponder::_stcMDNS_RRDomain::addLabel + * MDNSResponder::stcMDNS_RRDomain::addLabel */ -bool MDNSResponder::_stcMDNS_RRDomain::addLabel(const char* p_pcLabel, +bool MDNSResponder::stcMDNS_RRDomain::addLabel(const char* p_pcLabel, bool p_bPrependUnderline /*= false*/) { bool bResult = false; @@ -680,9 +682,9 @@ bool MDNSResponder::_stcMDNS_RRDomain::addLabel(const char* p_pcLabel, } /* - * MDNSResponder::_stcMDNS_RRDomain::compare + * MDNSResponder::stcMDNS_RRDomain::compare */ -bool MDNSResponder::_stcMDNS_RRDomain::compare(const _stcMDNS_RRDomain& p_Other) const { +bool MDNSResponder::stcMDNS_RRDomain::compare(const stcMDNS_RRDomain& p_Other) const { bool bResult = false; @@ -707,34 +709,34 @@ bool MDNSResponder::_stcMDNS_RRDomain::compare(const _stcMDNS_RRDomain& p_Other) } /* - * MDNSResponder::_stcMDNS_RRDomain::operator == + * MDNSResponder::stcMDNS_RRDomain::operator == */ -bool MDNSResponder::_stcMDNS_RRDomain::operator==(const _stcMDNS_RRDomain& p_Other) const { +bool MDNSResponder::stcMDNS_RRDomain::operator==(const stcMDNS_RRDomain& p_Other) const { return compare(p_Other); } /* - * MDNSResponder::_stcMDNS_RRDomain::operator != + * MDNSResponder::stcMDNS_RRDomain::operator != */ -bool MDNSResponder::_stcMDNS_RRDomain::operator!=(const _stcMDNS_RRDomain& p_Other) const { +bool MDNSResponder::stcMDNS_RRDomain::operator!=(const stcMDNS_RRDomain& p_Other) const { return !compare(p_Other); } /* - * MDNSResponder::_stcMDNS_RRDomain::operator > + * MDNSResponder::stcMDNS_RRDomain::operator > */ -bool MDNSResponder::_stcMDNS_RRDomain::operator>(const _stcMDNS_RRDomain& p_Other) const { +bool MDNSResponder::stcMDNS_RRDomain::operator>(const stcMDNS_RRDomain& p_Other) const { // TODO: Check, if this is a good idea... return !compare(p_Other); } /* - * MDNSResponder::_stcMDNS_RRDomain::c_strLength + * MDNSResponder::stcMDNS_RRDomain::c_strLength */ -size_t MDNSResponder::_stcMDNS_RRDomain::c_strLength(void) const { +size_t MDNSResponder::stcMDNS_RRDomain::c_strLength(void) const { size_t stLength = 0; @@ -747,9 +749,9 @@ size_t MDNSResponder::_stcMDNS_RRDomain::c_strLength(void) const { } /* - * MDNSResponder::_stcMDNS_RRDomain::c_str + * MDNSResponder::stcMDNS_RRDomain::c_str */ -bool MDNSResponder::_stcMDNS_RRDomain::c_str(char* p_pcBuffer) { +bool MDNSResponder::stcMDNS_RRDomain::c_str(char* p_pcBuffer) { bool bResult = false; @@ -776,9 +778,9 @@ bool MDNSResponder::_stcMDNS_RRDomain::c_str(char* p_pcBuffer) { */ /* - * MDNSResponder::_stcMDNS_RRAttributes::_stcMDNS_RRAttributes constructor + * MDNSResponder::stcMDNS_RRAttributes::stcMDNS_RRAttributes constructor */ -MDNSResponder::_stcMDNS_RRAttributes::_stcMDNS_RRAttributes(uint16_t p_u16Type /*= 0*/, +MDNSResponder::stcMDNS_RRAttributes::stcMDNS_RRAttributes(uint16_t p_u16Type /*= 0*/, uint16_t p_u16Class /*= 1 DNS_RRCLASS_IN Internet*/) : m_u16Type(p_u16Type), m_u16Class(p_u16Class) { @@ -786,17 +788,17 @@ MDNSResponder::_stcMDNS_RRAttributes::_stcMDNS_RRAttributes(uint16_t p_u16Type / } /* - * MDNSResponder::_stcMDNS_RRAttributes::_stcMDNS_RRAttributes copy-constructor + * MDNSResponder::stcMDNS_RRAttributes::stcMDNS_RRAttributes copy-constructor */ -MDNSResponder::_stcMDNS_RRAttributes::_stcMDNS_RRAttributes(const MDNSResponder::_stcMDNS_RRAttributes& p_Other) { +MDNSResponder::stcMDNS_RRAttributes::stcMDNS_RRAttributes(const MDNSResponder::stcMDNS_RRAttributes& p_Other) { operator=(p_Other); } /* - * MDNSResponder::_stcMDNS_RRAttributes::operator = + * MDNSResponder::stcMDNS_RRAttributes::operator = */ -MDNSResponder::_stcMDNS_RRAttributes& MDNSResponder::_stcMDNS_RRAttributes::operator=(const MDNSResponder::_stcMDNS_RRAttributes& p_Other) { +MDNSResponder::stcMDNS_RRAttributes& MDNSResponder::stcMDNS_RRAttributes::operator=(const MDNSResponder::stcMDNS_RRAttributes& p_Other) { if (&p_Other != this) { m_u16Type = p_Other.m_u16Type; @@ -814,24 +816,24 @@ MDNSResponder::_stcMDNS_RRAttributes& MDNSResponder::_stcMDNS_RRAttributes::oper */ /* - * MDNSResponder::_stcMDNS_RRHeader::_stcMDNS_RRHeader constructor + * MDNSResponder::stcMDNS_RRHeader::stcMDNS_RRHeader constructor */ -MDNSResponder::_stcMDNS_RRHeader::_stcMDNS_RRHeader(void) { +MDNSResponder::stcMDNS_RRHeader::stcMDNS_RRHeader(void) { } /* - * MDNSResponder::_stcMDNS_RRHeader::_stcMDNS_RRHeader copy-constructor + * MDNSResponder::stcMDNS_RRHeader::stcMDNS_RRHeader copy-constructor */ -MDNSResponder::_stcMDNS_RRHeader::_stcMDNS_RRHeader(const _stcMDNS_RRHeader& p_Other) { +MDNSResponder::stcMDNS_RRHeader::stcMDNS_RRHeader(const stcMDNS_RRHeader& p_Other) { operator=(p_Other); } /* - * MDNSResponder::_stcMDNS_RRHeader::operator = + * MDNSResponder::stcMDNS_RRHeader::operator = */ -MDNSResponder::_stcMDNS_RRHeader& MDNSResponder::_stcMDNS_RRHeader::operator=(const MDNSResponder::_stcMDNS_RRHeader& p_Other) { +MDNSResponder::stcMDNS_RRHeader& MDNSResponder::stcMDNS_RRHeader::operator=(const MDNSResponder::stcMDNS_RRHeader& p_Other) { if (&p_Other != this) { m_Domain = p_Other.m_Domain; @@ -841,9 +843,9 @@ MDNSResponder::_stcMDNS_RRHeader& MDNSResponder::_stcMDNS_RRHeader::operator=(co } /* - * MDNSResponder::_stcMDNS_RRHeader::clear + * MDNSResponder::stcMDNS_RRHeader::clear */ -bool MDNSResponder::_stcMDNS_RRHeader::clear(void) { +bool MDNSResponder::stcMDNS_RRHeader::clear(void) { m_Domain.clear(); return true; @@ -858,9 +860,9 @@ bool MDNSResponder::_stcMDNS_RRHeader::clear(void) { */ /* - * MDNSResponder::_stcMDNS_RRQuestion::_stcMDNS_RRQuestion constructor + * MDNSResponder::stcMDNS_RRQuestion::stcMDNS_RRQuestion constructor */ -MDNSResponder::_stcMDNS_RRQuestion::_stcMDNS_RRQuestion(void) +MDNSResponder::stcMDNS_RRQuestion::stcMDNS_RRQuestion(void) : m_pNext(0), m_bUnicast(false) { @@ -876,9 +878,9 @@ MDNSResponder::_stcMDNS_RRQuestion::_stcMDNS_RRQuestion(void) */ /* - * MDNSResponder::_stcMDNS_RRAnswer::_stcMDNS_RRAnswer constructor + * MDNSResponder::stcMDNS_RRAnswer::stcMDNS_RRAnswer constructor */ -MDNSResponder::_stcMDNS_RRAnswer::_stcMDNS_RRAnswer(enuAnswerType p_AnswerType, +MDNSResponder::stcMDNS_RRAnswer::stcMDNS_RRAnswer(enuAnswerType p_AnswerType, const MDNSResponder::stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL) : m_pNext(0), @@ -892,24 +894,24 @@ MDNSResponder::_stcMDNS_RRAnswer::_stcMDNS_RRAnswer(enuAnswerType p_AnswerType, } /* - * MDNSResponder::_stcMDNS_RRAnswer::~_stcMDNS_RRAnswer destructor + * MDNSResponder::stcMDNS_RRAnswer::~stcMDNS_RRAnswer destructor */ -MDNSResponder::_stcMDNS_RRAnswer::~_stcMDNS_RRAnswer(void) { +MDNSResponder::stcMDNS_RRAnswer::~stcMDNS_RRAnswer(void) { } /* - * MDNSResponder::_stcMDNS_RRAnswer::answerType + * MDNSResponder::stcMDNS_RRAnswer::answerType */ -MDNSResponder::enuAnswerType MDNSResponder::_stcMDNS_RRAnswer::answerType(void) const { +MDNSResponder::enuAnswerType MDNSResponder::stcMDNS_RRAnswer::answerType(void) const { return m_AnswerType; } /* - * MDNSResponder::_stcMDNS_RRAnswer::clear + * MDNSResponder::stcMDNS_RRAnswer::clear */ -bool MDNSResponder::_stcMDNS_RRAnswer::clear(void) { +bool MDNSResponder::stcMDNS_RRAnswer::clear(void) { m_pNext = 0; m_Header.clear(); @@ -927,9 +929,9 @@ bool MDNSResponder::_stcMDNS_RRAnswer::clear(void) { #ifdef MDNS_IP4_SUPPORT /* - * MDNSResponder::_stcMDNS_RRAnswerA::stcMDNS_RRAnswerA constructor + * MDNSResponder::stcMDNS_RRAnswerA::stcMDNS_RRAnswerA constructor */ - MDNSResponder::_stcMDNS_RRAnswerA::_stcMDNS_RRAnswerA(const MDNSResponder::stcMDNS_RRHeader& p_Header, + MDNSResponder::stcMDNS_RRAnswerA::stcMDNS_RRAnswerA(const MDNSResponder::stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL) : stcMDNS_RRAnswer(AnswerType_A, p_Header, p_u32TTL), m_IPAddress(0, 0, 0, 0) { @@ -937,17 +939,17 @@ bool MDNSResponder::_stcMDNS_RRAnswer::clear(void) { } /* - * MDNSResponder::_stcMDNS_RRAnswerA::_stcMDNS_RRAnswerA destructor + * MDNSResponder::stcMDNS_RRAnswerA::stcMDNS_RRAnswerA destructor */ - MDNSResponder::_stcMDNS_RRAnswerA::~_stcMDNS_RRAnswerA(void) { + MDNSResponder::stcMDNS_RRAnswerA::~stcMDNS_RRAnswerA(void) { clear(); } /* - * MDNSResponder::_stcMDNS_RRAnswerA::clear + * MDNSResponder::stcMDNS_RRAnswerA::clear */ - bool MDNSResponder::_stcMDNS_RRAnswerA::clear(void) { + bool MDNSResponder::stcMDNS_RRAnswerA::clear(void) { m_IPAddress = IPAddress(0, 0, 0, 0); return true; @@ -964,26 +966,26 @@ bool MDNSResponder::_stcMDNS_RRAnswer::clear(void) { */ /* - * MDNSResponder::_stcMDNS_RRAnswerPTR::_stcMDNS_RRAnswerPTR constructor + * MDNSResponder::stcMDNS_RRAnswerPTR::stcMDNS_RRAnswerPTR constructor */ -MDNSResponder::_stcMDNS_RRAnswerPTR::_stcMDNS_RRAnswerPTR(const MDNSResponder::stcMDNS_RRHeader& p_Header, +MDNSResponder::stcMDNS_RRAnswerPTR::stcMDNS_RRAnswerPTR(const MDNSResponder::stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL) : stcMDNS_RRAnswer(AnswerType_PTR, p_Header, p_u32TTL) { } /* - * MDNSResponder::_stcMDNS_RRAnswerPTR::~_stcMDNS_RRAnswerPTR destructor + * MDNSResponder::stcMDNS_RRAnswerPTR::~stcMDNS_RRAnswerPTR destructor */ -MDNSResponder::_stcMDNS_RRAnswerPTR::~_stcMDNS_RRAnswerPTR(void) { +MDNSResponder::stcMDNS_RRAnswerPTR::~stcMDNS_RRAnswerPTR(void) { clear(); } /* - * MDNSResponder::_stcMDNS_RRAnswerPTR::clear + * MDNSResponder::stcMDNS_RRAnswerPTR::clear */ -bool MDNSResponder::_stcMDNS_RRAnswerPTR::clear(void) { +bool MDNSResponder::stcMDNS_RRAnswerPTR::clear(void) { m_PTRDomain.clear(); return true; @@ -991,7 +993,7 @@ bool MDNSResponder::_stcMDNS_RRAnswerPTR::clear(void) { /** - * MDNSResponder::_stcMDNS_RRAnswerTXT + * MDNSResponder::stcMDNS_RRAnswerTXT * * A MDNS TXT answer object. * Extends the base class by a MDNS TXT items list member. @@ -999,26 +1001,26 @@ bool MDNSResponder::_stcMDNS_RRAnswerPTR::clear(void) { */ /* - * MDNSResponder::_stcMDNS_RRAnswerTXT::_stcMDNS_RRAnswerTXT constructor + * MDNSResponder::stcMDNS_RRAnswerTXT::stcMDNS_RRAnswerTXT constructor */ -MDNSResponder::_stcMDNS_RRAnswerTXT::_stcMDNS_RRAnswerTXT(const MDNSResponder::stcMDNS_RRHeader& p_Header, +MDNSResponder::stcMDNS_RRAnswerTXT::stcMDNS_RRAnswerTXT(const MDNSResponder::stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL) : stcMDNS_RRAnswer(AnswerType_TXT, p_Header, p_u32TTL) { } /* - * MDNSResponder::_stcMDNS_RRAnswerTXT::~_stcMDNS_RRAnswerTXT destructor + * MDNSResponder::stcMDNS_RRAnswerTXT::~stcMDNS_RRAnswerTXT destructor */ -MDNSResponder::_stcMDNS_RRAnswerTXT::~_stcMDNS_RRAnswerTXT(void) { +MDNSResponder::stcMDNS_RRAnswerTXT::~stcMDNS_RRAnswerTXT(void) { clear(); } /* - * MDNSResponder::_stcMDNS_RRAnswerTXT::clear + * MDNSResponder::stcMDNS_RRAnswerTXT::clear */ -bool MDNSResponder::_stcMDNS_RRAnswerTXT::clear(void) { +bool MDNSResponder::stcMDNS_RRAnswerTXT::clear(void) { m_Txts.clear(); return true; @@ -1035,26 +1037,26 @@ bool MDNSResponder::_stcMDNS_RRAnswerTXT::clear(void) { #ifdef MDNS_IP6_SUPPORT /* - * MDNSResponder::_stcMDNS_RRAnswerAAAA::_stcMDNS_RRAnswerAAAA constructor + * MDNSResponder::stcMDNS_RRAnswerAAAA::stcMDNS_RRAnswerAAAA constructor */ - MDNSResponder::_stcMDNS_RRAnswerAAAA::_stcMDNS_RRAnswerAAAA(const MDNSResponder::stcMDNS_RRHeader& p_Header, + MDNSResponder::stcMDNS_RRAnswerAAAA::stcMDNS_RRAnswerAAAA(const MDNSResponder::stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL) : stcMDNS_RRAnswer(AnswerType_AAAA, p_Header, p_u32TTL) { } /* - * MDNSResponder::_stcMDNS_RRAnswerAAAA::~_stcMDNS_RRAnswerAAAA destructor + * MDNSResponder::stcMDNS_RRAnswerAAAA::~stcMDNS_RRAnswerAAAA destructor */ - MDNSResponder::_stcMDNS_RRAnswerAAAA::~_stcMDNS_RRAnswerAAAA(void) { + MDNSResponder::stcMDNS_RRAnswerAAAA::~stcMDNS_RRAnswerAAAA(void) { clear(); } /* - * MDNSResponder::_stcMDNS_RRAnswerAAAA::clear + * MDNSResponder::stcMDNS_RRAnswerAAAA::clear */ - bool MDNSResponder::_stcMDNS_RRAnswerAAAA::clear(void) { + bool MDNSResponder::stcMDNS_RRAnswerAAAA::clear(void) { return true; } @@ -1070,9 +1072,9 @@ bool MDNSResponder::_stcMDNS_RRAnswerTXT::clear(void) { */ /* - * MDNSResponder::_stcMDNS_RRAnswerSRV::_stcMDNS_RRAnswerSRV constructor + * MDNSResponder::stcMDNS_RRAnswerSRV::stcMDNS_RRAnswerSRV constructor */ -MDNSResponder::_stcMDNS_RRAnswerSRV::_stcMDNS_RRAnswerSRV(const MDNSResponder::stcMDNS_RRHeader& p_Header, +MDNSResponder::stcMDNS_RRAnswerSRV::stcMDNS_RRAnswerSRV(const MDNSResponder::stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL) : stcMDNS_RRAnswer(AnswerType_SRV, p_Header, p_u32TTL), m_u16Priority(0), @@ -1082,17 +1084,17 @@ MDNSResponder::_stcMDNS_RRAnswerSRV::_stcMDNS_RRAnswerSRV(const MDNSResponder::s } /* - * MDNSResponder::_stcMDNS_RRAnswerSRV::~_stcMDNS_RRAnswerSRV destructor + * MDNSResponder::stcMDNS_RRAnswerSRV::~stcMDNS_RRAnswerSRV destructor */ -MDNSResponder::_stcMDNS_RRAnswerSRV::~_stcMDNS_RRAnswerSRV(void) { +MDNSResponder::stcMDNS_RRAnswerSRV::~stcMDNS_RRAnswerSRV(void) { clear(); } /* - * MDNSResponder::_stcMDNS_RRAnswerSRV::clear + * MDNSResponder::stcMDNS_RRAnswerSRV::clear */ -bool MDNSResponder::_stcMDNS_RRAnswerSRV::clear(void) { +bool MDNSResponder::stcMDNS_RRAnswerSRV::clear(void) { m_u16Priority = 0; m_u16Weight = 0; @@ -1111,9 +1113,9 @@ bool MDNSResponder::_stcMDNS_RRAnswerSRV::clear(void) { */ /* - * MDNSResponder::_stcMDNS_RRAnswerGeneric::_stcMDNS_RRAnswerGeneric constructor + * MDNSResponder::stcMDNS_RRAnswerGeneric::stcMDNS_RRAnswerGeneric constructor */ -MDNSResponder::_stcMDNS_RRAnswerGeneric::_stcMDNS_RRAnswerGeneric(const stcMDNS_RRHeader& p_Header, +MDNSResponder::stcMDNS_RRAnswerGeneric::stcMDNS_RRAnswerGeneric(const stcMDNS_RRHeader& p_Header, uint32_t p_u32TTL) : stcMDNS_RRAnswer(AnswerType_Generic, p_Header, p_u32TTL), m_u16RDLength(0), @@ -1122,17 +1124,17 @@ MDNSResponder::_stcMDNS_RRAnswerGeneric::_stcMDNS_RRAnswerGeneric(const stcMDNS_ } /* - * MDNSResponder::_stcMDNS_RRAnswerGeneric::~_stcMDNS_RRAnswerGeneric destructor + * MDNSResponder::stcMDNS_RRAnswerGeneric::~stcMDNS_RRAnswerGeneric destructor */ -MDNSResponder::_stcMDNS_RRAnswerGeneric::~_stcMDNS_RRAnswerGeneric(void) { +MDNSResponder::stcMDNS_RRAnswerGeneric::~stcMDNS_RRAnswerGeneric(void) { clear(); } /* - * MDNSResponder::_stcMDNS_RRAnswerGeneric::clear + * MDNSResponder::stcMDNS_RRAnswerGeneric::clear */ -bool MDNSResponder::_stcMDNS_RRAnswerGeneric::clear(void) { +bool MDNSResponder::stcMDNS_RRAnswerGeneric::clear(void) { if (m_pu8RDData) { delete[] m_pu8RDData; @@ -1152,9 +1154,9 @@ bool MDNSResponder::_stcMDNS_RRAnswerGeneric::clear(void) { */ /* - * MDNSResponder::_stcProbeInformation::_stcProbeInformation constructor + * MDNSResponder::stcProbeInformation::stcProbeInformation constructor */ -MDNSResponder::_stcProbeInformation::_stcProbeInformation(void) +MDNSResponder::stcProbeInformation::stcProbeInformation(void) : m_ProbingStatus(ProbingStatus_WaitingForData), m_u8ProbesSent(0), //m_ulNextProbeTimeout(0), @@ -1166,9 +1168,9 @@ MDNSResponder::_stcProbeInformation::_stcProbeInformation(void) } /* - * MDNSResponder::_stcProbeInformation::clear + * MDNSResponder::stcProbeInformation::clear */ -bool MDNSResponder::_stcProbeInformation::clear(bool p_bClearUserdata /*= false*/) { +bool MDNSResponder::stcProbeInformation::clear(bool p_bClearUserdata /*= false*/) { m_ProbingStatus = ProbingStatus_WaitingForData; m_u8ProbesSent = 0; @@ -1195,9 +1197,9 @@ bool MDNSResponder::_stcProbeInformation::clear(bool p_bClearUserdata /*= false* */ /* - * MDNSResponder::_stcMDNSService::_stcMDNSService constructor + * MDNSResponder::stcMDNSService::stcMDNSService constructor */ -MDNSResponder::_stcMDNSService::_stcMDNSService(const char* p_pcName /*= 0*/, +MDNSResponder::stcMDNSService::stcMDNSService(const char* p_pcName /*= 0*/, const char* p_pcService /*= 0*/, const char* p_pcProtocol /*= 0*/) : m_pNext(0), @@ -1216,9 +1218,9 @@ MDNSResponder::_stcMDNSService::_stcMDNSService(const char* p_pcName /*= 0*/, } /* - * MDNSResponder::_stcMDNSService::~_stcMDNSService destructor + * MDNSResponder::stcMDNSService::~stcMDNSService destructor */ -MDNSResponder::_stcMDNSService::~_stcMDNSService(void) { +MDNSResponder::stcMDNSService::~stcMDNSService(void) { releaseName(); releaseService(); @@ -1226,9 +1228,9 @@ MDNSResponder::_stcMDNSService::~_stcMDNSService(void) { } /* - * MDNSResponder::_stcMDNSService::setName + * MDNSResponder::stcMDNSService::setName */ -bool MDNSResponder::_stcMDNSService::setName(const char* p_pcName) { +bool MDNSResponder::stcMDNSService::setName(const char* p_pcName) { bool bResult = false; @@ -1247,9 +1249,9 @@ bool MDNSResponder::_stcMDNSService::setName(const char* p_pcName) { } /* - * MDNSResponder::_stcMDNSService::releaseName + * MDNSResponder::stcMDNSService::releaseName */ -bool MDNSResponder::_stcMDNSService::releaseName(void) { +bool MDNSResponder::stcMDNSService::releaseName(void) { if (m_pcName) { delete[] m_pcName; @@ -1259,9 +1261,9 @@ bool MDNSResponder::_stcMDNSService::releaseName(void) { } /* - * MDNSResponder::_stcMDNSService::setService + * MDNSResponder::stcMDNSService::setService */ -bool MDNSResponder::_stcMDNSService::setService(const char* p_pcService) { +bool MDNSResponder::stcMDNSService::setService(const char* p_pcService) { bool bResult = false; @@ -1280,9 +1282,9 @@ bool MDNSResponder::_stcMDNSService::setService(const char* p_pcService) { } /* - * MDNSResponder::_stcMDNSService::releaseService + * MDNSResponder::stcMDNSService::releaseService */ -bool MDNSResponder::_stcMDNSService::releaseService(void) { +bool MDNSResponder::stcMDNSService::releaseService(void) { if (m_pcService) { delete[] m_pcService; @@ -1292,9 +1294,9 @@ bool MDNSResponder::_stcMDNSService::releaseService(void) { } /* - * MDNSResponder::_stcMDNSService::setProtocol + * MDNSResponder::stcMDNSService::setProtocol */ -bool MDNSResponder::_stcMDNSService::setProtocol(const char* p_pcProtocol) { +bool MDNSResponder::stcMDNSService::setProtocol(const char* p_pcProtocol) { bool bResult = false; @@ -1313,9 +1315,9 @@ bool MDNSResponder::_stcMDNSService::setProtocol(const char* p_pcProtocol) { } /* - * MDNSResponder::_stcMDNSService::releaseProtocol + * MDNSResponder::stcMDNSService::releaseProtocol */ -bool MDNSResponder::_stcMDNSService::releaseProtocol(void) { +bool MDNSResponder::stcMDNSService::releaseProtocol(void) { if (m_pcProtocol) { delete[] m_pcProtocol; @@ -1368,18 +1370,18 @@ bool MDNSResponder::_stcMDNSService::releaseProtocol(void) { */ /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::_stcTTL constructor + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::stcTTL constructor */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::_stcTTL(uint32_t p_u32TTL /*= 0*/) +MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::stcTTL(uint32_t p_u32TTL /*= 0*/) : m_bUpdateScheduled(false) { set(p_u32TTL * 1000); } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::set + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::set */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::set(uint32_t p_u32TTL) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::set(uint32_t p_u32TTL) { m_TTLTimeFlag.restart(p_u32TTL * 1000); m_bUpdateScheduled = false; @@ -1388,21 +1390,21 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::set(uint32_t p_u3 } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::has80Percent + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::has80Percent */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::has80Percent(void) const { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::has80Percent(void) const { - return ((m_TTLTimeFlag.timeout()) && + return ((m_TTLTimeFlag.getTimeout()) && (!m_bUpdateScheduled) && - (m_TTLTimeFlag.hypotheticalTimeout((m_TTLTimeFlag.timeout() * 800) / 1000))); + (m_TTLTimeFlag.hypotheticalTimeout((m_TTLTimeFlag.getTimeout() * 800) / 1000))); } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::isOutdated + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::isOutdated */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::isOutdated(void) const { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::isOutdated(void) const { - return ((m_TTLTimeFlag.timeout()) && + return ((m_TTLTimeFlag.getTimeout()) && (m_TTLTimeFlag.flagged())); } @@ -1414,9 +1416,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcTTL::isOutdated(void) */ /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address::_stcIP4Address constructor + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address::stcIP4Address constructor */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address::_stcIP4Address(IPAddress p_IPAddress, +MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address::stcIP4Address(IPAddress p_IPAddress, uint32_t p_u32TTL /*= 0*/) : m_pNext(0), m_IPAddress(p_IPAddress), @@ -1430,9 +1432,9 @@ MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address::_stcIP4Address( */ /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcAnswer constructor + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcAnswer constructor */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcAnswer(void) +MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcAnswer(void) : m_pNext(0), m_pcServiceDomain(0), m_pcHostDomain(0), @@ -1448,17 +1450,17 @@ MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcAnswer(void) } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::~_stcAnswer destructor + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::~stcAnswer destructor */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::~_stcAnswer(void) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer::~stcAnswer(void) { clear(); } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::clear + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::clear */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::clear(void) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::clear(void) { return ((releaseTxts()) && #ifdef MDNS_IP4_SUPPORT @@ -1472,12 +1474,12 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::clear(void) { } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocServiceDomain + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::allocServiceDomain * * Alloc memory for the char array representation of the service domain. * */ -char* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocServiceDomain(size_t p_stLength) { +char* MDNSResponder::stcMDNSServiceQuery::stcAnswer::allocServiceDomain(size_t p_stLength) { releaseServiceDomain(); if (p_stLength) { @@ -1487,9 +1489,9 @@ char* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocServiceDomain(size_t } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseServiceDomain + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseServiceDomain */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseServiceDomain(void) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseServiceDomain(void) { if (m_pcServiceDomain) { delete[] m_pcServiceDomain; @@ -1499,12 +1501,12 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseServiceDomain(void) } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocHostDomain + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::allocHostDomain * * Alloc memory for the char array representation of the host domain. * */ -char* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocHostDomain(size_t p_stLength) { +char* MDNSResponder::stcMDNSServiceQuery::stcAnswer::allocHostDomain(size_t p_stLength) { releaseHostDomain(); if (p_stLength) { @@ -1514,9 +1516,9 @@ char* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocHostDomain(size_t p_ } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseHostDomain + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseHostDomain */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseHostDomain(void) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseHostDomain(void) { if (m_pcHostDomain) { delete[] m_pcHostDomain; @@ -1526,12 +1528,12 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseHostDomain(void) { } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocTxts + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::allocTxts * * Alloc memory for the char array representation of the TXT items. * */ -char* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocTxts(size_t p_stLength) { +char* MDNSResponder::stcMDNSServiceQuery::stcAnswer::allocTxts(size_t p_stLength) { releaseTxts(); if (p_stLength) { @@ -1541,9 +1543,9 @@ char* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::allocTxts(size_t p_stLeng } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseTxts + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseTxts */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseTxts(void) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseTxts(void) { if (m_pcTxts) { delete[] m_pcTxts; @@ -1554,9 +1556,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseTxts(void) { #ifdef MDNS_IP4_SUPPORT /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseIP4Addresses + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseIP4Addresses */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseIP4Addresses(void) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseIP4Addresses(void) { while (m_pIP4Addresses) { stcIP4Address* pNext = m_pIP4Addresses->m_pNext; @@ -1567,9 +1569,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseIP4Addresses(void) } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::addIP4Address + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::addIP4Address */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::addIP4Address(MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* p_pIP4Address) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::addIP4Address(MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address* p_pIP4Address) { bool bResult = false; @@ -1582,9 +1584,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::addIP4Address(MDNSResponde } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::removeIP4Address + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::removeIP4Address */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::removeIP4Address(MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* p_pIP4Address) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::removeIP4Address(MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address* p_pIP4Address) { bool bResult = false; @@ -1609,17 +1611,17 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::removeIP4Address(MDNSRespo } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP4Address (const) + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP4Address (const) */ -const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP4Address(const IPAddress& p_IPAddress) const { +const MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP4Address(const IPAddress& p_IPAddress) const { - return (stcIP4Address*)(((const _stcAnswer*)this)->findIP4Address(p_IPAddress)); + return (stcIP4Address*)(((const stcAnswer*)this)->findIP4Address(p_IPAddress)); } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP4Address + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP4Address */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP4Address(const IPAddress& p_IPAddress) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP4Address(const IPAddress& p_IPAddress) { stcIP4Address* pIP4Address = m_pIP4Addresses; while (pIP4Address) { @@ -1632,9 +1634,9 @@ MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* MDNSResponder:: } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP4AddressCount + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP4AddressCount */ -uint32_t MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP4AddressCount(void) const { +uint32_t MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP4AddressCount(void) const { uint32_t u32Count = 0; @@ -1647,17 +1649,17 @@ uint32_t MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP4AddressCount(void) } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP4AddressAtIndex + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP4AddressAtIndex */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP4AddressAtIndex(uint32_t p_u32Index) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP4AddressAtIndex(uint32_t p_u32Index) { - return (stcIP4Address*)(((const _stcAnswer*)this)->IP4AddressAtIndex(p_u32Index)); + return (stcIP4Address*)(((const stcAnswer*)this)->IP4AddressAtIndex(p_u32Index)); } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP4AddressAtIndex (const) + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP4AddressAtIndex (const) */ -const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP4AddressAtIndex(uint32_t p_u32Index) const { +const MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP4Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP4AddressAtIndex(uint32_t p_u32Index) const { const stcIP4Address* pIP4Address = 0; @@ -1673,9 +1675,9 @@ const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP4Address* MDNSRespo #ifdef MDNS_IP6_SUPPORT /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseIP6Addresses + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseIP6Addresses */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseIP6Addresses(void) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::releaseIP6Addresses(void) { while (m_pIP6Addresses) { stcIP6Address* pNext = m_pIP6Addresses->m_pNext; @@ -1686,9 +1688,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::releaseIP6Addresses(void) } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::addIP6Address + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::addIP6Address */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::addIP6Address(MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* p_pIP6Address) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::addIP6Address(MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP6Address* p_pIP6Address) { bool bResult = false; @@ -1701,9 +1703,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::addIP6Address(MDNSResponde } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::removeIP6Address + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::removeIP6Address */ -bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::removeIP6Address(MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* p_pIP6Address) { +bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::removeIP6Address(MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP6Address* p_pIP6Address) { bool bResult = false; @@ -1728,17 +1730,17 @@ bool MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::removeIP6Address(MDNSRespo } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP6Address + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP6Address */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP6Address(const IP6Address& p_IPAddress) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP6Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP6Address(const IP6Address& p_IPAddress) { - return (stcIP6Address*)(((const _stcAnswer*)this)->findIP6Address(p_IPAddress)); + return (stcIP6Address*)(((const stcAnswer*)this)->findIP6Address(p_IPAddress)); } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP6Address (const) + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP6Address (const) */ -const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::findIP6Address(const IPAddress& p_IPAddress) const { +const MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP6Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::findIP6Address(const IPAddress& p_IPAddress) const { const stcIP6Address* pIP6Address = m_pIP6Addresses; while (pIP6Address) { @@ -1751,9 +1753,9 @@ const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* MDNSRespo } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP6AddressCount + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP6AddressCount */ -uint32_t MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP6AddressCount(void) const { +uint32_t MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP6AddressCount(void) const { uint32_t u32Count = 0; @@ -1766,17 +1768,17 @@ uint32_t MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP6AddressCount(void) } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP6AddressAtIndex (const) + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP6AddressAtIndex (const) */ -const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP6AddressAtIndex(uint32_t p_u32Index) const { +const MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP6Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP6AddressAtIndex(uint32_t p_u32Index) const { - return (stcIP6Address*)(((const _stcAnswer*)this)->IP6AddressAtIndex(p_u32Index)); + return (stcIP6Address*)(((const stcAnswer*)this)->IP6AddressAtIndex(p_u32Index)); } /* - * MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP6AddressAtIndex + * MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP6AddressAtIndex */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::IP6AddressAtIndex(uint32_t p_u32Index) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcIP6Address* MDNSResponder::stcMDNSServiceQuery::stcAnswer::IP6AddressAtIndex(uint32_t p_u32Index) { stcIP6Address* pIP6Address = 0; @@ -1809,9 +1811,9 @@ MDNSResponder::_stcMDNSServiceQuery::_stcAnswer::_stcIP6Address* MDNSResponder:: */ /* - * MDNSResponder::_stcMDNSServiceQuery::_stcMDNSServiceQuery constructor + * MDNSResponder::stcMDNSServiceQuery::stcMDNSServiceQuery constructor */ -MDNSResponder::_stcMDNSServiceQuery::_stcMDNSServiceQuery(void) +MDNSResponder::stcMDNSServiceQuery::stcMDNSServiceQuery(void) : m_pNext(0), m_fnCallback(0), m_pUserdata(0), @@ -1823,17 +1825,17 @@ MDNSResponder::_stcMDNSServiceQuery::_stcMDNSServiceQuery(void) } /* - * MDNSResponder::_stcMDNSServiceQuery::~_stcMDNSServiceQuery destructor + * MDNSResponder::stcMDNSServiceQuery::~stcMDNSServiceQuery destructor */ -MDNSResponder::_stcMDNSServiceQuery::~_stcMDNSServiceQuery(void) { +MDNSResponder::stcMDNSServiceQuery::~stcMDNSServiceQuery(void) { clear(); } /* - * MDNSResponder::_stcMDNSServiceQuery::clear + * MDNSResponder::stcMDNSServiceQuery::clear */ -bool MDNSResponder::_stcMDNSServiceQuery::clear(void) { +bool MDNSResponder::stcMDNSServiceQuery::clear(void) { m_fnCallback = 0; m_pUserdata = 0; @@ -1848,9 +1850,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::clear(void) { } /* - * MDNSResponder::_stcMDNSServiceQuery::answerCount + * MDNSResponder::stcMDNSServiceQuery::answerCount */ -uint32_t MDNSResponder::_stcMDNSServiceQuery::answerCount(void) const { +uint32_t MDNSResponder::stcMDNSServiceQuery::answerCount(void) const { uint32_t u32Count = 0; @@ -1863,9 +1865,9 @@ uint32_t MDNSResponder::_stcMDNSServiceQuery::answerCount(void) const { } /* - * MDNSResponder::_stcMDNSServiceQuery::answerAtIndex + * MDNSResponder::stcMDNSServiceQuery::answerAtIndex */ -const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* MDNSResponder::_stcMDNSServiceQuery::answerAtIndex(uint32_t p_u32Index) const { +const MDNSResponder::stcMDNSServiceQuery::stcAnswer* MDNSResponder::stcMDNSServiceQuery::answerAtIndex(uint32_t p_u32Index) const { const stcAnswer* pAnswer = 0; @@ -1879,17 +1881,17 @@ const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* MDNSResponder::_stcMDNSSe } /* - * MDNSResponder::_stcMDNSServiceQuery::answerAtIndex + * MDNSResponder::stcMDNSServiceQuery::answerAtIndex */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* MDNSResponder::_stcMDNSServiceQuery::answerAtIndex(uint32_t p_u32Index) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer* MDNSResponder::stcMDNSServiceQuery::answerAtIndex(uint32_t p_u32Index) { - return (stcAnswer*)(((const _stcMDNSServiceQuery*)this)->answerAtIndex(p_u32Index)); + return (stcAnswer*)(((const stcMDNSServiceQuery*)this)->answerAtIndex(p_u32Index)); } /* - * MDNSResponder::_stcMDNSServiceQuery::indexOfAnswer + * MDNSResponder::stcMDNSServiceQuery::indexOfAnswer */ -uint32_t MDNSResponder::_stcMDNSServiceQuery::indexOfAnswer(const MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* p_pAnswer) const { +uint32_t MDNSResponder::stcMDNSServiceQuery::indexOfAnswer(const MDNSResponder::stcMDNSServiceQuery::stcAnswer* p_pAnswer) const { uint32_t u32Index = 0; @@ -1902,9 +1904,9 @@ uint32_t MDNSResponder::_stcMDNSServiceQuery::indexOfAnswer(const MDNSResponder: } /* - * MDNSResponder::_stcMDNSServiceQuery::addAnswer + * MDNSResponder::stcMDNSServiceQuery::addAnswer */ -bool MDNSResponder::_stcMDNSServiceQuery::addAnswer(MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* p_pAnswer) { +bool MDNSResponder::stcMDNSServiceQuery::addAnswer(MDNSResponder::stcMDNSServiceQuery::stcAnswer* p_pAnswer) { bool bResult = false; @@ -1917,9 +1919,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::addAnswer(MDNSResponder::_stcMDNSServi } /* - * MDNSResponder::_stcMDNSServiceQuery::removeAnswer + * MDNSResponder::stcMDNSServiceQuery::removeAnswer */ -bool MDNSResponder::_stcMDNSServiceQuery::removeAnswer(MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* p_pAnswer) { +bool MDNSResponder::stcMDNSServiceQuery::removeAnswer(MDNSResponder::stcMDNSServiceQuery::stcAnswer* p_pAnswer) { bool bResult = false; @@ -1944,9 +1946,9 @@ bool MDNSResponder::_stcMDNSServiceQuery::removeAnswer(MDNSResponder::_stcMDNSSe } /* - * MDNSResponder::_stcMDNSServiceQuery::findAnswerForServiceDomain + * MDNSResponder::stcMDNSServiceQuery::findAnswerForServiceDomain */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* MDNSResponder::_stcMDNSServiceQuery::findAnswerForServiceDomain(const MDNSResponder::stcMDNS_RRDomain& p_ServiceDomain) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer* MDNSResponder::stcMDNSServiceQuery::findAnswerForServiceDomain(const MDNSResponder::stcMDNS_RRDomain& p_ServiceDomain) { stcAnswer* pAnswer = m_pAnswers; while (pAnswer) { @@ -1959,9 +1961,9 @@ MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* MDNSResponder::_stcMDNSServiceQ } /* - * MDNSResponder::_stcMDNSServiceQuery::findAnswerForHostDomain + * MDNSResponder::stcMDNSServiceQuery::findAnswerForHostDomain */ -MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* MDNSResponder::_stcMDNSServiceQuery::findAnswerForHostDomain(const MDNSResponder::stcMDNS_RRDomain& p_HostDomain) { +MDNSResponder::stcMDNSServiceQuery::stcAnswer* MDNSResponder::stcMDNSServiceQuery::findAnswerForHostDomain(const MDNSResponder::stcMDNS_RRDomain& p_HostDomain) { stcAnswer* pAnswer = m_pAnswers; while (pAnswer) { @@ -1992,9 +1994,9 @@ MDNSResponder::_stcMDNSServiceQuery::_stcAnswer* MDNSResponder::_stcMDNSServiceQ */ /* - * MDNSResponder::stcMDNSSendParameter::_stcDomainCacheItem::_stcDomainCacheItem constructor + * MDNSResponder::stcMDNSSendParameter::stcDomainCacheItem::stcDomainCacheItem constructor */ -MDNSResponder::stcMDNSSendParameter::_stcDomainCacheItem::_stcDomainCacheItem(const void* p_pHostnameOrService, +MDNSResponder::stcMDNSSendParameter::stcDomainCacheItem::stcDomainCacheItem(const void* p_pHostnameOrService, bool p_bAdditionalData, uint32_t p_u16Offset) : m_pNext(0), @@ -2009,9 +2011,9 @@ MDNSResponder::stcMDNSSendParameter::_stcDomainCacheItem::_stcDomainCacheItem(co */ /* - * MDNSResponder::_stcMDNSSendParameter::_stcMDNSSendParameter constructor + * MDNSResponder::stcMDNSSendParameter::stcMDNSSendParameter constructor */ -MDNSResponder::_stcMDNSSendParameter::_stcMDNSSendParameter(void) +MDNSResponder::stcMDNSSendParameter::stcMDNSSendParameter(void) : m_pQuestions(0), m_pDomainCacheItems(0) { @@ -2019,17 +2021,17 @@ MDNSResponder::_stcMDNSSendParameter::_stcMDNSSendParameter(void) } /* - * MDNSResponder::_stcMDNSSendParameter::~_stcMDNSSendParameter destructor + * MDNSResponder::stcMDNSSendParameter::~stcMDNSSendParameter destructor */ -MDNSResponder::_stcMDNSSendParameter::~_stcMDNSSendParameter(void) { +MDNSResponder::stcMDNSSendParameter::~stcMDNSSendParameter(void) { clear(); } /* - * MDNSResponder::_stcMDNSSendParameter::clear + * MDNSResponder::stcMDNSSendParameter::clear */ -bool MDNSResponder::_stcMDNSSendParameter::clear(void) { +bool MDNSResponder::stcMDNSSendParameter::clear(void) { m_u16ID = 0; m_u8HostReplyMask = 0; @@ -2057,18 +2059,18 @@ bool MDNSResponder::_stcMDNSSendParameter::clear(void) { } /* - * MDNSResponder::_stcMDNSSendParameter::shiftOffset + * MDNSResponder::stcMDNSSendParameter::shiftOffset */ -bool MDNSResponder::_stcMDNSSendParameter::shiftOffset(uint16_t p_u16Shift) { +bool MDNSResponder::stcMDNSSendParameter::shiftOffset(uint16_t p_u16Shift) { m_u16Offset += p_u16Shift; return true; } /* - * MDNSResponder::_stcMDNSSendParameter::addDomainCacheItem + * MDNSResponder::stcMDNSSendParameter::addDomainCacheItem */ -bool MDNSResponder::_stcMDNSSendParameter::addDomainCacheItem(const void* p_pHostnameOrService, +bool MDNSResponder::stcMDNSSendParameter::addDomainCacheItem(const void* p_pHostnameOrService, bool p_bAdditionalData, uint16_t p_u16Offset) { @@ -2086,9 +2088,9 @@ bool MDNSResponder::_stcMDNSSendParameter::addDomainCacheItem(const void* p_pHos } /* - * MDNSResponder::_stcMDNSSendParameter::findCachedDomainOffset + * MDNSResponder::stcMDNSSendParameter::findCachedDomainOffset */ -uint16_t MDNSResponder::_stcMDNSSendParameter::findCachedDomainOffset(const void* p_pHostnameOrService, +uint16_t MDNSResponder::stcMDNSSendParameter::findCachedDomainOffset(const void* p_pHostnameOrService, bool p_bAdditionalData) const { const stcDomainCacheItem* pCacheItem = m_pDomainCacheItems; @@ -2102,8 +2104,9 @@ uint16_t MDNSResponder::_stcMDNSSendParameter::findCachedDomainOffset(const void return (pCacheItem ? pCacheItem->m_u16Offset : 0); } -} // namespace LEAmDNS - +} // namespace MDNSImplementation + +} // namespace esp8266 diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Transfer.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Transfer.cpp old mode 100755 new mode 100644 index de3a85585..c803a26f0 --- a/libraries/ESP8266mDNS/src/LEAmDNS_Transfer.cpp +++ b/libraries/ESP8266mDNS/src/LEAmDNS_Transfer.cpp @@ -30,10 +30,12 @@ extern "C" { #include "LEAmDNS_Priv.h" +namespace esp8266 { + /* - * namespace LEAmDNS + * LEAmDNS */ -namespace LEAmDNS { +namespace MDNSImplementation { /** * CONST STRINGS @@ -154,7 +156,7 @@ bool MDNSResponder::_prepareMDNSMessage(MDNSResponder::stcMDNSSendParameter& p_r bool bResult = true; // Prepare header; count answers - _stcMDNS_MsgHeader msgHeader(0, p_rSendParameter.m_bResponse, 0, p_rSendParameter.m_bAuthorative); + stcMDNS_MsgHeader msgHeader(0, p_rSendParameter.m_bResponse, 0, p_rSendParameter.m_bAuthorative); // If this is a response, the answers are anwers, // else this is a query or probe and the answers go into auth section uint16_t& ru16Answers = (p_rSendParameter.m_bResponse @@ -1627,7 +1629,9 @@ bool MDNSResponder::_writeMDNSAnswer_SRV(MDNSResponder::stcMDNSService& p_rServi return bResult; } -} // namespace LEAmDNS +} // namespace MDNSImplementation + +} // namespace esp8266 diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_lwIPdefs.h b/libraries/ESP8266mDNS/src/LEAmDNS_lwIPdefs.h index 7088cb97e..d923f9a97 100644 --- a/libraries/ESP8266mDNS/src/LEAmDNS_lwIPdefs.h +++ b/libraries/ESP8266mDNS/src/LEAmDNS_lwIPdefs.h @@ -22,8 +22,8 @@ * */ -#ifndef LEAMDNS_LWIPDEFS_H -#define LEAMDNS_LWIPDEFS_H +#ifndef MDNS_LWIPDEFS_H +#define MDNS_LWIPDEFS_H #include #if LWIP_VERSION_MAJOR == 1 @@ -41,4 +41,4 @@ #endif -#endif // LEAMDNS_LWIPDEFS_H +#endif // MDNS_LWIPDEFS_H