Skip to content

Functional update, host and service probes #5653

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 29 commits into from
Feb 5, 2019
Merged

Functional update, host and service probes #5653

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
29 commits
Select commit Hold shift + click to select a range
5674603
Functional update, host and service probes
hreintke Jan 23, 2019
57c9ba4
Fix ServiceMonitor.ino warnings
hreintke Jan 23, 2019
168de73
Adding MDNSServiceQueryCallback functional
hreintke Jan 23, 2019
ab86859
DynamicServices Functional
hreintke Jan 24, 2019
8f8e90f
Fix ServiceMonitor to match latest MDNSServiceInfo
hreintke Jan 24, 2019
e3dee4f
Fix unused variable in LEAdns.h
hreintke Jan 24, 2019
b237160
mDNS_Clock.ino fix
hreintke Jan 24, 2019
6bb6e90
example restyle
d-a-v Jan 24, 2019
45fbbb9
Merge pull request #1 from d-a-v/FunctionalMDNS
hreintke Jan 24, 2019
b74735c
Merge branch 'master' into FunctionalMDNS
d-a-v Jan 24, 2019
516ed01
Merge branch 'master' into FunctionalMDNS
d-a-v Jan 24, 2019
639f097
Add keyValues and answerInfo
hreintke Jan 26, 2019
5da1832
Waring and formattin fix
hreintke Jan 26, 2019
249b325
Change struct MDNSServiceInfo { MDNSServiceInfo(MDNSResponder ...
hreintke Jan 26, 2019
db0d502
Make AnswerType user friendly
hreintke Jan 27, 2019
0ece474
Update ServiceInfo example
hreintke Jan 27, 2019
fd2cd67
Code cleanup
hreintke Jan 27, 2019
88f1547
AnswerType update, Astyle update servicemonitor
hreintke Jan 27, 2019
819a7e0
Update clock example to webserver
hreintke Jan 28, 2019
f667b56
Second typedef for probe callbacks
hreintke Jan 29, 2019
902f453
Merge branch 'master' into FunctionalMDNS
devyte Jan 31, 2019
7068938
Optimizations
hreintke Feb 1, 2019
772d633
Update callbacks to void
hreintke Feb 1, 2019
c189902
esp32 compatibility
hreintke Feb 1, 2019
8d3f912
std::map to const char*
hreintke Feb 3, 2019
603b659
Fix emplace_back call
hreintke Feb 4, 2019
e3f86d2
Change Dynamic callback to void(...)
hreintke Feb 4, 2019
0f0edb5
Add WiFi events reset() in close()
hreintke Feb 4, 2019
699656d
Merge branch 'master' into FunctionalMDNS
devyte Feb 5, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
115 changes: 79 additions & 36 deletions libraries/ESP8266mDNS/examples/LEAmDNS/mDNS_ServiceMonitor/mDNS_ServiceMonitor.ino
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -85,12 +85,39 @@ bool setStationHostname(const char* p_pcHostname) {
}
return true;
}


/*
MDNSServiceQueryCallback
*/
bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder, // The MDNS responder object

bool MDNSServiceQueryCallback (MDNSResponder::MDNSServiceInfo serviceInfo, uint32_t p_u32ServiceQueryAnswerMask, bool p_bSetContent)
{
String answerInfo;
switch (p_u32ServiceQueryAnswerMask){
case MDNSResponder::ServiceQueryAnswerType_ServiceDomain :
answerInfo = "ServiceDomain " + serviceInfo.serviceDomain();
break;
case MDNSResponder::MDNSResponder::ServiceQueryAnswerType_HostDomainAndPort :
answerInfo = "HostDomainAndPort " + serviceInfo.hostDomain() + ":" + String(serviceInfo.hostPort());
break;
case MDNSResponder::MDNSResponder::MDNSResponder::ServiceQueryAnswerType_IP4Address :
answerInfo = "IP4Address ";
for (IPAddress ip : serviceInfo.IPAdresses()){
answerInfo += "- " + ip.toString();
};
break;
case MDNSResponder::MDNSResponder::MDNSResponder::ServiceQueryAnswerType_Txts :
answerInfo = "TXT " + serviceInfo.txtValue();

break;
default :
answerInfo = "Unknown";
}
Serial.printf("Answer %s %s\n",answerInfo.c_str(),p_bSetContent ? "Modified" : "Deleted");

return true;
}

bool MDNSServiceQueryCallback1(MDNSResponder* p_pMDNSResponder, // The MDNS responder object
const MDNSResponder::hMDNSServiceQuery p_hServiceQuery, // Handle to the service query
uint32_t p_u32AnswerIndex, // Index of the updated answer
uint32_t p_u32ServiceQueryAnswerMask, // Mask for the updated component
Expand Down Expand Up @@ -119,11 +146,12 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder,
}
} else if (MDNSResponder::ServiceQueryAnswerType_IP4Address & p_u32ServiceQueryAnswerMask) {
if (p_bSetContent) {
Serial.printf("MDNSServiceQueryCallback: IP4 address added/updated for service '%s':\n",
Serial.printf("MDNSServiceQueryCallback: IP4 address added/updated for service '%s': ",
p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex));
for (uint32_t u = 0; u < p_pMDNSResponder->answerIP4AddressCount(p_hServiceQuery, p_u32AnswerIndex); ++u) {
Serial.printf("- %s\n", p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u).toString().c_str());
Serial.printf("- %s ", p_pMDNSResponder->answerIP4Address(p_hServiceQuery, p_u32AnswerIndex, u).toString().c_str());
}
Serial.printf("\n");
} else {
Serial.printf("MDNSServiceQueryCallback: IP4 address removed from service '%s'\n",
p_pMDNSResponder->answerServiceDomain(p_hServiceQuery, p_u32AnswerIndex));
Expand Down Expand Up @@ -181,7 +209,23 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder,
}

/*
MDNSProbeResultCallback
MDNSServiceProbeResultCallback
Probe result callback for Services
*/

bool serviceProbeResult (String p_pcServiceName,
const MDNSResponder::hMDNSService p_hMDNSService,
bool p_bProbeResult)
{
(void) p_hMDNSService;
Serial.printf("MDNSServiceProbeResultCallback: Service %s probe %s\n", p_pcServiceName.c_str(), (p_bProbeResult ? "succeeded." : "failed!"));
return true;
}



/*
MDNSHostProbeResultCallback

Probe result callback for the host domain.
If the domain is free, the host domain is set and the http service is
Expand All @@ -190,17 +234,10 @@ bool MDNSServiceQueryCallback(MDNSResponder* p_pMDNSResponder,
restarted via p_pMDNSResponder->setHostname().

*/
bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder,
const char* p_pcDomainName,
const MDNSResponder::hMDNSService p_hService,
bool p_bProbeResult,
void* p_pUserdata) {
(void) p_pUserdata;

if ((p_pMDNSResponder) &&
(0 == p_hService)) { // Called for host domain
bool hostProbeResult (String p_pcDomainName, bool p_bProbeResult) {

Serial.printf("MDNSProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName, (p_bProbeResult ? "free" : "already USED!"));
Serial.printf("MDNSHostProbeResultCallback: Host domain '%s.local' is %s\n", p_pcDomainName.c_str(), (p_bProbeResult ? "free" : "already USED!"));

if (true == p_bProbeResult) {
// Set station hostname
Expand All @@ -212,18 +249,20 @@ bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder,

if (!hMDNSService) {
// Add a 'http.tcp' service to port 'SERVICE_PORT', using the host domain as instance domain
hMDNSService = p_pMDNSResponder->addService(0, "http", "tcp", SERVICE_PORT);
hMDNSService = MDNS.addService(0, "http", "tcp", SERVICE_PORT);
if (hMDNSService) {
MDNS.setServiceProbeResultCallback(hMDNSService, serviceProbeResult);

// Add some '_http._tcp' protocol specific MDNS service TXT items
// See: http://www.dns-sd.org/txtrecords.html#http
p_pMDNSResponder->addServiceTxt(hMDNSService, "user", "");
p_pMDNSResponder->addServiceTxt(hMDNSService, "password", "");
p_pMDNSResponder->addServiceTxt(hMDNSService, "path", "/");
MDNS.addServiceTxt(hMDNSService, "user", "");
MDNS.addServiceTxt(hMDNSService, "password", "");
MDNS.addServiceTxt(hMDNSService, "path", "/");
}

// Install dynamic 'http.tcp' service query
if (!hMDNSServiceQuery) {
hMDNSServiceQuery = p_pMDNSResponder->installServiceQuery("http", "tcp", MDNSServiceQueryCallback, 0);
hMDNSServiceQuery = MDNS.installServiceQuery("http", "tcp", MDNSServiceQueryCallback);
if (hMDNSServiceQuery) {
Serial.printf("MDNSProbeResultCallback: Service query for 'http.tcp' services installed.\n");
} else {
Expand All @@ -233,14 +272,14 @@ bool MDNSProbeResultCallback(MDNSResponder* p_pMDNSResponder,
}
}
} else {
// Change hostname, use '-' as divider between base name and index
if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) {
p_pMDNSResponder->setHostname(pcHostDomain);
} else {
Serial.println("MDNSProbeResultCallback: FAILED to update hostname!");
// Change hostname, use '-' as divider between base name and index
if (MDNSResponder::indexDomain(pcHostDomain, "-", 0)) {
MDNS.setHostname(pcHostDomain);
} else {
Serial.println("MDNSProbeResultCallback: FAILED to update hostname!");
}
}
}
}

return true;
}

Expand All @@ -251,15 +290,19 @@ void handleHTTPRequest() {
Serial.println("");
Serial.println("HTTP Request");

IPAddress ip = WiFi.localIP();
String ipStr = String(ip[0]) + '.' + String(ip[1]) + '.' + String(ip[2]) + '.' + String(ip[3]);
String s = "<!DOCTYPE HTML>\r\n<html><h3><head>Hello from ";
s += WiFi.hostname() + ".local at " + WiFi.localIP().toString() + "</h3></head>";
s += WiFi.hostname() + ".local at " + ipStr + "</h3></head>";
s += "<br/><h4>Local HTTP services are :</h4><ol>";
s += strHTTPServices;
// done :-)
s += "</ol></html>";
s += "</ol><br/>";

Serial.println("Sending 200");
server.send(200, "text/html", s);
Serial.println("Done with request");
Serial.printf("FM %d\n",ESP.getFreeHeap());
}

/*
Expand Down Expand Up @@ -288,12 +331,14 @@ void setup(void) {
// Setup HTTP server
server.on("/", handleHTTPRequest);

// Setup MDNS responder
MDNS.setProbeResultCallback(MDNSProbeResultCallback, 0);
// Setup MDNS responders
MDNS.setHostProbeResultCallback(hostProbeResult);


// Init the (currently empty) host domain string with 'esp8266'
if ((!MDNSResponder::indexDomain(pcHostDomain, 0, "esp8266")) ||
(!MDNS.begin(pcHostDomain))) {
Serial.println("Error setting up MDNS responder!");
Serial.println(" Error setting up MDNS responder!");
while (1) { // STOP
delay(1000);
}
Expand All @@ -305,13 +350,11 @@ void setup(void) {
Serial.println("HTTP server started");
}


/*
loop
*/
void loop(void) {
// Check if a request has come in
server.handleClient();
// Allow MDNS processing
MDNS.update();

}

24 changes: 12 additions & 12 deletions libraries/ESP8266mDNS/src/LEAmDNS.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -759,10 +759,10 @@ uint16_t MDNSResponder::port(const uint32_t p_u32AnswerIndex) {
* - answerTxts
*
*/
//Functional
MDNSResponder::hMDNSServiceQuery MDNSResponder::installServiceQuery(const char* p_pcService,
const char* p_pcProtocol,
MDNSResponder::MDNSServiceQueryCallbackFn p_fnCallback,
void* p_pUserdata) {
MDNSResponder::MDNSServiceQueryCallbackFunc p_fnCallback) {
hMDNSServiceQuery hResult = 0;

stcMDNSServiceQuery* pServiceQuery = 0;
Expand All @@ -775,7 +775,7 @@ MDNSResponder::hMDNSServiceQuery MDNSResponder::installServiceQuery(const char*
(_buildDomainForService(p_pcService, p_pcProtocol, pServiceQuery->m_ServiceTypeDomain))) {

pServiceQuery->m_fnCallback = p_fnCallback;
pServiceQuery->m_pUserdata = p_pUserdata;
pServiceQuery->m_pUserdata = 0;
pServiceQuery->m_bLegacyQuery = false;

if (_sendMDNSServiceQuery(*pServiceQuery)) {
Expand Down Expand Up @@ -1030,11 +1030,11 @@ const char* MDNSResponder::answerTxts(const MDNSResponder::hMDNSServiceQuery p_h
* When succeeded, the host or service domain will be announced by the MDNS responder.
*
*/
bool MDNSResponder::setProbeResultCallback(MDNSResponder::MDNSProbeResultCallbackFn p_fnCallback,
void* p_pUserdata) {
m_HostProbeInformation.m_fnProbeResultCallback = p_fnCallback;
m_HostProbeInformation.m_pProbeResultCallbackUserdata = p_pUserdata;
//Functional
bool MDNSResponder::setHostProbeResultCallback(MDNSResponder::MDNSHostProbeResultCallbackFn p_fnCallback) {

m_HostProbeInformation.m_fnHostProbeResultCallback = p_fnCallback;
m_HostProbeInformation.m_pProbeResultCallbackUserdata = 0;

return true;
}
Expand All @@ -1049,14 +1049,14 @@ bool MDNSResponder::setProbeResultCallback(MDNSResponder::MDNSProbeResultCallbac
*
*/
bool MDNSResponder::setServiceProbeResultCallback(const MDNSResponder::hMDNSService p_hService,
MDNSResponder::MDNSProbeResultCallbackFn p_fnCallback,
void* p_pUserdata) {
MDNSResponder::MDNSServiceProbeResultCallbackFn p_fnCallback) {

bool bResult = false;

stcMDNSService* pService = _findService(p_hService);
if (pService) {
pService->m_ProbeInformation.m_fnProbeResultCallback = p_fnCallback;
pService->m_ProbeInformation.m_pProbeResultCallbackUserdata = p_pUserdata;
pService->m_ProbeInformation.m_fnServiceProbeResultCallback = p_fnCallback;
pService->m_ProbeInformation.m_pProbeResultCallbackUserdata = 0;

bResult = true;
}
Expand Down
Loading