31#if defined(_WIN32) && !defined(_CRT_SECURE_NO_WARNINGS)
32#define _CRT_SECURE_NO_WARNINGS 1
43#define sleep(x) Sleep(x * 1000)
53#ifndef OCPN_ENABLE_MDNS_DEBUG
57static char addrbuffer[64];
58static char namebuffer[256];
59static char sendbuffer[1024];
61static struct sockaddr_in service_address_ipv4;
62static struct sockaddr_in6 service_address_ipv6;
64volatile sig_atomic_t running_server = 1;
68 mdns_string_t service;
69 mdns_string_t hostname;
70 mdns_string_t service_instance;
71 mdns_string_t hostname_qualified;
72 struct sockaddr_in address_ipv4;
73 struct sockaddr_in6 address_ipv6;
75 mdns_record_t record_ptr;
76 mdns_record_t record_srv;
77 mdns_record_t record_a;
78 mdns_record_t record_aaaa;
79 mdns_record_t txt_record[2];
83int ocpn_service_callback(
int sock,
const struct sockaddr* from,
size_t addrlen,
84 mdns_entry_type_t entry, uint16_t query_id,
85 uint16_t rtype, uint16_t rclass, uint32_t ttl,
86 const void* data,
size_t size,
size_t name_offset,
87 size_t name_length,
size_t record_offset,
88 size_t record_length,
void* user_data) {
90 if (entry != MDNS_ENTRYTYPE_QUESTION)
return 0;
92 const char dns_sd[] =
"_services._dns-sd._udp.local.";
95 mdns_string_t fromaddrstr =
96 ip_address_to_string(addrbuffer,
sizeof(addrbuffer), from, addrlen);
98 size_t offset = name_offset;
100 mdns_string_extract(data, size, &offset, namebuffer,
sizeof(namebuffer));
102 const char* record_name = 0;
103 if (rtype == MDNS_RECORDTYPE_PTR)
105 else if (rtype == MDNS_RECORDTYPE_SRV)
107 else if (rtype == MDNS_RECORDTYPE_A)
109 else if (rtype == MDNS_RECORDTYPE_AAAA)
110 record_name =
"AAAA";
111 else if (rtype == MDNS_RECORDTYPE_TXT)
113 else if (rtype == MDNS_RECORDTYPE_ANY)
117 printf(
"Query %s %.*s\n", record_name, MDNS_STRING_FORMAT(name));
119 if ((name.length == (
sizeof(dns_sd) - 1)) &&
120 (strncmp(name.str, dns_sd,
sizeof(dns_sd) - 1) == 0)) {
121 if ((rtype == MDNS_RECORDTYPE_PTR) || (rtype == MDNS_RECORDTYPE_ANY)) {
128 mdns_record_t answer;
130 answer.type = MDNS_RECORDTYPE_PTR;
131 answer.data.ptr.name = service->service;
134 uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
135 printf(
" --> answer %.*s (%s)\n",
136 MDNS_STRING_FORMAT(answer.data.ptr.name),
137 (unicast ?
"unicast" :
"multicast"));
140 mdns_query_answer_unicast(sock, from, addrlen, sendbuffer,
141 sizeof(sendbuffer), query_id,
142 (mdns_record_type_t)rtype, name.str,
143 name.length, answer, 0, 0, 0, 0);
145 mdns_query_answer_multicast(sock, sendbuffer,
sizeof(sendbuffer),
149 }
else if ((name.length == service->service.length) &&
150 (strncmp(name.str, service->service.str, name.length) == 0)) {
151 if ((rtype == MDNS_RECORDTYPE_PTR) || (rtype == MDNS_RECORDTYPE_ANY)) {
163 mdns_record_t answer = service->record_ptr;
165 mdns_record_t additional[5]{{}};
166 size_t additional_count = 0;
170 additional[additional_count++] = service->record_srv;
173 if (service->address_ipv4.sin_family == AF_INET)
174 additional[additional_count++] = service->record_a;
175 if (service->address_ipv6.sin6_family == AF_INET6)
176 additional[additional_count++] = service->record_aaaa;
185 uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
186 printf(
" --> answer %.*s (%s)\n",
187 MDNS_STRING_FORMAT(service->record_ptr.data.ptr.name),
188 (unicast ?
"unicast" :
"multicast"));
191 mdns_query_answer_unicast(
192 sock, from, addrlen, sendbuffer,
sizeof(sendbuffer), query_id,
193 (mdns_record_type)rtype, name.str, name.length, answer, 0, 0,
194 additional, additional_count);
196 mdns_query_answer_multicast(sock, sendbuffer,
sizeof(sendbuffer),
197 answer, 0, 0, additional, additional_count);
200 }
else if ((name.length == service->service_instance.length) &&
201 (strncmp(name.str, service->service_instance.str, name.length) ==
203 if ((rtype == MDNS_RECORDTYPE_SRV) || (rtype == MDNS_RECORDTYPE_ANY)) {
212 mdns_record_t answer = service->record_srv;
214 mdns_record_t additional[5]{{}};
215 size_t additional_count = 0;
218 if (service->address_ipv4.sin_family == AF_INET)
219 additional[additional_count++] = service->record_a;
220 if (service->address_ipv6.sin6_family == AF_INET6)
221 additional[additional_count++] = service->record_aaaa;
226 additional[additional_count++] = service->txt_record[0];
227 additional[additional_count++] = service->txt_record[1];
230 uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
231 printf(
" --> answer %.*s port %d (%s)\n",
232 MDNS_STRING_FORMAT(service->record_srv.data.srv.name),
233 service->port, (unicast ?
"unicast" :
"multicast"));
236 mdns_query_answer_unicast(
237 sock, from, addrlen, sendbuffer,
sizeof(sendbuffer), query_id,
238 (mdns_record_type)rtype, name.str, name.length, answer, 0, 0,
239 additional, additional_count);
241 mdns_query_answer_multicast(sock, sendbuffer,
sizeof(sendbuffer),
242 answer, 0, 0, additional, additional_count);
245 }
else if ((name.length == service->hostname_qualified.length) &&
246 (strncmp(name.str, service->hostname_qualified.str, name.length) ==
248 if (((rtype == MDNS_RECORDTYPE_A) || (rtype == MDNS_RECORDTYPE_ANY)) &&
249 (service->address_ipv4.sin_family == AF_INET)) {
256 mdns_record_t answer = service->record_a;
258 mdns_record_t additional[5]{{}};
259 size_t additional_count = 0;
262 if (service->address_ipv6.sin6_family == AF_INET6)
263 additional[additional_count++] = service->record_aaaa;
268 additional[additional_count++] = service->txt_record[0];
269 additional[additional_count++] = service->txt_record[1];
272 uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
273 mdns_string_t addrstr =
274 ip_address_to_string(addrbuffer,
sizeof(addrbuffer),
275 (
struct sockaddr*)&service->record_a.data.a.addr,
276 sizeof(service->record_a.data.a.addr));
277 printf(
" --> answer %.*s IPv4 %.*s (%s)\n",
278 MDNS_STRING_FORMAT(service->record_a.name),
279 MDNS_STRING_FORMAT(addrstr), (unicast ?
"unicast" :
"multicast"));
282 mdns_query_answer_unicast(
283 sock, from, addrlen, sendbuffer,
sizeof(sendbuffer), query_id,
284 (mdns_record_type)rtype, name.str, name.length, answer, 0, 0,
285 additional, additional_count);
287 mdns_query_answer_multicast(sock, sendbuffer,
sizeof(sendbuffer),
288 answer, 0, 0, additional, additional_count);
290 }
else if (((rtype == MDNS_RECORDTYPE_AAAA) ||
291 (rtype == MDNS_RECORDTYPE_ANY)) &&
292 (service->address_ipv6.sin6_family == AF_INET6)) {
299 mdns_record_t answer = service->record_aaaa;
301 mdns_record_t additional[5]{{}};
302 size_t additional_count = 0;
305 if (service->address_ipv4.sin_family == AF_INET)
306 additional[additional_count++] = service->record_a;
311 additional[additional_count++] = service->txt_record[0];
312 additional[additional_count++] = service->txt_record[1];
315 uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
316 mdns_string_t addrstr = ip_address_to_string(
317 addrbuffer,
sizeof(addrbuffer),
318 (
struct sockaddr*)&service->record_aaaa.data.aaaa.addr,
319 sizeof(service->record_aaaa.data.aaaa.addr));
320 printf(
" --> answer %.*s IPv6 %.*s (%s)\n",
321 MDNS_STRING_FORMAT(service->record_aaaa.name),
322 MDNS_STRING_FORMAT(addrstr), (unicast ?
"unicast" :
"multicast"));
325 mdns_query_answer_unicast(
326 sock, from, addrlen, sendbuffer,
sizeof(sendbuffer), query_id,
327 (mdns_record_type)rtype, name.str, name.length, answer, 0, 0,
328 additional, additional_count);
330 mdns_query_answer_multicast(sock, sendbuffer,
sizeof(sendbuffer),
331 answer, 0, 0, additional, additional_count);
339void service_mdns(
const char* hostname,
const char* service_name,
343 open_service_sockets(sockets,
sizeof(sockets) /
sizeof(sockets[0]));
344 if (num_sockets <= 0) {
345 printf(
"Failed to open any client sockets\n");
348 printf(
"Opened %d socket%s for mDNS service\n", num_sockets,
349 num_sockets ?
"s" :
"");
351 size_t service_name_length = strlen(service_name);
352 if (!service_name_length) {
353 printf(
"Invalid service name\n");
357 char* service_name_buffer = (
char*)malloc(service_name_length + 2);
358 memcpy(service_name_buffer, service_name, service_name_length);
359 if (service_name_buffer[service_name_length - 1] !=
'.')
360 service_name_buffer[service_name_length++] =
'.';
361 service_name_buffer[service_name_length] = 0;
362 service_name = service_name_buffer;
364 printf(
"Service mDNS: %s:%d\n", service_name, service_port);
365 printf(
"Hostname: %s\n", hostname);
367 size_t capacity = 2048;
368 void* buffer = malloc(capacity);
370 mdns_string_t service_string;
371 service_string.str = service_name;
372 service_string.length = strlen(service_name);
373 mdns_string_t hostname_string;
374 hostname_string.str = hostname;
375 hostname_string.length = strlen(hostname);
378 char service_instance_buffer[256] = {0};
379 snprintf(service_instance_buffer,
sizeof(service_instance_buffer) - 1,
380 "%.*s.%.*s", MDNS_STRING_FORMAT(hostname_string),
381 MDNS_STRING_FORMAT(service_string));
383 mdns_string_t service_instance_string;
384 service_instance_string.str = service_instance_buffer;
385 service_instance_string.length = strlen(service_instance_buffer);
388 char qualified_hostname_buffer[256] = {0};
389 snprintf(qualified_hostname_buffer,
sizeof(qualified_hostname_buffer) - 1,
390 "%.*s.local.", MDNS_STRING_FORMAT(hostname_string));
391 mdns_string_t hostname_qualified_string;
392 hostname_qualified_string.str = qualified_hostname_buffer;
393 hostname_qualified_string.length = strlen(qualified_hostname_buffer);
396 service.service = service_string;
397 service.hostname = hostname_string;
398 service.service_instance = service_instance_string;
399 service.hostname_qualified = hostname_qualified_string;
400 service.address_ipv4 = service_address_ipv4;
401 service.address_ipv6 = service_address_ipv6;
402 service.port = service_port;
408 service.record_ptr.name = service.service;
409 service.record_ptr.type = MDNS_RECORDTYPE_PTR;
410 service.record_ptr.rclass = 0;
411 service.record_ptr.ttl = 0;
412 service.record_ptr.data.ptr.name = service.service_instance;
416 service.record_srv.name = service.service_instance;
417 service.record_srv.type = MDNS_RECORDTYPE_SRV;
418 service.record_srv.data.srv.name = service.hostname_qualified;
419 service.record_srv.data.srv.port = service.port;
420 service.record_srv.data.srv.priority = 0;
421 service.record_srv.data.srv.weight = 0;
422 service.record_srv.rclass = 0;
423 service.record_srv.ttl = 0;
427 service.record_a.name = service.hostname_qualified;
428 service.record_a.type = MDNS_RECORDTYPE_A;
429 service.record_a.data.a.addr = service.address_ipv4;
430 service.record_a.rclass = 0;
431 service.record_a.ttl = 0;
433 service.record_aaaa.name = service.hostname_qualified;
434 service.record_aaaa.type = MDNS_RECORDTYPE_AAAA;
435 service.record_aaaa.data.aaaa.addr = service.address_ipv6;
436 service.record_aaaa.rclass = 0;
437 service.record_aaaa.ttl = 0;
442 service.txt_record[0].name = service.service_instance;
443 service.txt_record[0].type = MDNS_RECORDTYPE_TXT;
444 service.txt_record[0].data.txt.key = {MDNS_STRING_CONST(
"test")};
445 service.txt_record[0].data.txt.value = {MDNS_STRING_CONST(
"1")};
446 service.txt_record[0].rclass = 0;
447 service.txt_record[0].ttl = 0;
449 service.txt_record[1].name = service.service_instance;
450 service.txt_record[1].type = MDNS_RECORDTYPE_TXT;
451 service.txt_record[1].data.txt.key = {MDNS_STRING_CONST(
"other")};
452 service.txt_record[1].data.txt.value = {MDNS_STRING_CONST(
"value")};
453 service.txt_record[1].rclass = 0;
454 service.txt_record[1].ttl = 0;
459 printf(
"Sending announce\n");
460 mdns_record_t additional[5]{{}};
461 size_t additional_count = 0;
462 additional[additional_count++] = service.record_srv;
463 if (service.address_ipv4.sin_family == AF_INET)
464 additional[additional_count++] = service.record_a;
465 if (service.address_ipv6.sin6_family == AF_INET6)
466 additional[additional_count++] = service.record_aaaa;
470 for (
int isock = 0; isock < num_sockets; ++isock)
471 mdns_announce_multicast(sockets[isock], buffer, capacity,
472 service.record_ptr, 0, 0, additional,
477 while (running_server) {
481 for (
int isock = 0; isock < num_sockets; ++isock) {
482 if (sockets[isock] >= nfds) nfds = sockets[isock] + 1;
483 FD_SET(sockets[isock], &readfs);
486 struct timeval timeout;
488 timeout.tv_usec = 100000;
490 if (select(nfds, &readfs, 0, 0, &timeout) >= 0) {
491 for (
int isock = 0; isock < num_sockets; ++isock) {
492 if (FD_ISSET(sockets[isock], &readfs)) {
493 mdns_socket_listen(sockets[isock], buffer, capacity,
494 ocpn_service_callback, &service);
496 FD_SET(sockets[isock], &readfs);
505 printf(
"Sending goodbye\n");
506 mdns_record_t additional[5]{{}};
507 size_t additional_count = 0;
508 additional[additional_count++] = service.record_srv;
509 if (service.address_ipv4.sin_family == AF_INET)
510 additional[additional_count++] = service.record_a;
511 if (service.address_ipv6.sin6_family == AF_INET6)
512 additional[additional_count++] = service.record_aaaa;
513 additional[additional_count++] = service.txt_record[0];
514 additional[additional_count++] = service.txt_record[1];
516 for (
int isock = 0; isock < num_sockets; ++isock)
517 mdns_goodbye_multicast(sockets[isock], buffer, capacity,
518 service.record_ptr, 0, 0, additional,
523 free(service_name_buffer);
525 for (
int isock = 0; isock < num_sockets; ++isock)
526 mdns_socket_close(sockets[isock]);
527 printf(
"Closed socket%s\n", num_sockets ?
"s" :
"");
535int StartMDNSService(std::string hostname, std::string service_name,
538 service = service_name;
540 std::thread mdns_service_thread(service_mdns, host.c_str(), service.c_str(),
542 mdns_service_thread.detach();
547bool StopMDNSService() {
return true; }