react-native-zeroconf 0.16.1 → 0.17.1

package/windows/RNZeroconf/ZeroconfCore.cpp

@@ -0,0 +1,1095 @@
+#include "ZeroconfCore.h"
+
+#include <iphlpapi.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cstdio>
+#include <cwchar>
+#include <cwctype>
+#include <thread>
+
+#pragma comment(lib, "dnsapi.lib")
+#pragma comment(lib, "iphlpapi.lib")
+#pragma comment(lib, "ws2_32.lib")
+
+namespace rnzeroconf {
+
+using After = std::vector<std::function<void()>>;
+
+enum class Kind { Browse, Resolve, Publication };
+
+struct Operation {
+  Operation(Kind kind, Zeroconf *owner) : kind(kind), owner(owner) {}
+  virtual ~Operation() = default;
+  const Kind kind;
+  Zeroconf *owner;
+};
+
+struct Resolve : Operation {
+  explicit Resolve(Zeroconf *owner) : Operation(Kind::Resolve, owner) {}
+  // Empty for resolveService()
+  std::weak_ptr<Browse> browse;
+  std::string scanId;
+  std::wstring name;
+  std::wstring key;
+  std::wstring queryName;
+  ULONG interfaceIndex = 0;
+  DNS_SERVICE_RESOLVE_REQUEST request{};
+  DNS_SERVICE_CANCEL cancel{};
+  bool done = false;
+  // Scans: retried once after a timeout
+  bool retried = false;
+  ServiceCallback promiseResolve;
+  ErrorCallback promiseReject;
+};
+
+struct Browse : Operation {
+  explicit Browse(Zeroconf *owner) : Operation(Kind::Browse, owner) {}
+  std::string scanId;
+  std::wstring regType;
+  std::wstring domain;
+  std::wstring queryName;
+  bool typesOnly = false;
+  ULONG interfaceIndex = 0;
+  DWORD resolveTimeoutMs = 5000;
+  DNS_SERVICE_BROWSE_REQUEST request{};
+  DNS_SERVICE_CANCEL cancel{};
+  // Lower-case PTR target -> name reported to JavaScript
+  std::map<std::wstring, std::wstring> found;
+  std::map<std::wstring, std::shared_ptr<Resolve>> resolves;
+  // Service type scans: the types answered by the network, the others come from this app's publications
+  std::set<std::wstring> networkTypes;
+  // Instances resolved once, and their last TXT and SRV data, to resolve them again when they change
+  std::set<std::wstring> resolved;
+  std::map<std::wstring, std::wstring> recordData;
+};
+
+struct Publication : Operation {
+  enum class State { Registering, Registered, Deregistering, Done };
+  explicit Publication(Zeroconf *owner) : Operation(Kind::Publication, owner) {}
+  ~Publication() override {
+    if (instance) {
+      DnsServiceFreeInstance(instance);
+    }
+  }
+  State state = State::Registering;
+  std::wstring requestedName;
+  std::wstring name;
+  std::wstring regType;
+  std::wstring domain;
+  uint16_t port = 0;
+  TxtPairs txt;
+  ULONG interfaceIndex = 0;
+  // Updates publish again without emitting unpublished and published
+  bool announce = true;
+  PDNS_SERVICE_INSTANCE instance = nullptr;
+  DNS_SERVICE_REGISTER_REQUEST request{};
+  DNS_SERVICE_CANCEL cancel{};
+  ServiceCallback onRegistered;
+  ErrorCallback onRegisterFailed;
+  ServiceCallback onDeregistered;
+};
+
+namespace {
+
+// windns.h callbacks receive a context pointer, they only use operations still in this registry,
+// so a callback arriving after a cancel never touches a freed operation
+std::mutex registryMutex;
+std::map<void *, std::shared_ptr<Operation>> &Registry() {
+  static std::map<void *, std::shared_ptr<Operation>> registry;
+  return registry;
+}
+
+void Track(const std::shared_ptr<Operation> &operation) {
+  std::lock_guard<std::mutex> lock(registryMutex);
+  Registry()[operation.get()] = operation;
+}
+
+void Untrack(Operation *operation) {
+  std::lock_guard<std::mutex> lock(registryMutex);
+  Registry().erase(operation);
+}
+
+template <typename T>
+std::shared_ptr<T> Tracked(void *context) {
+  std::lock_guard<std::mutex> lock(registryMutex);
+  auto it = Registry().find(context);
+  if (it == Registry().end() || it->second->owner == nullptr) {
+    return nullptr;
+  }
+  return std::static_pointer_cast<T>(it->second);
+}
+
+bool DebugEnabled() {
+  static const bool enabled = GetEnvironmentVariableW(L"RNZEROCONF_DEBUG", nullptr, 0) > 0;
+  return enabled;
+}
+
+std::wstring Lower(std::wstring value) {
+  std::transform(value.begin(), value.end(), value.begin(), [](wchar_t c) { return static_cast<wchar_t>(std::towlower(c)); });
+  return value;
+}
+
+bool EndsWith(const std::wstring &value, const std::wstring &suffix) {
+  return value.size() >= suffix.size() && value.compare(value.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+std::wstring WithoutTrailingDot(std::wstring value) {
+  while (!value.empty() && value.back() == L'.') {
+    value.pop_back();
+  }
+  return value;
+}
+
+// "local." -> "local"
+std::wstring DomainName(const std::wstring &domain) {
+  std::wstring name = WithoutTrailingDot(domain);
+  return name.empty() ? L"local" : name;
+}
+
+// "printer" or "_printer" -> "_printer"
+std::wstring Label(const std::wstring &value) {
+  return value.empty() || value[0] == L'_' ? value : L"_" + value;
+}
+
+// "My Printer._ipp._tcp.local" -> "My Printer"
+std::wstring InstanceName(const std::wstring &fullName, const std::wstring &regType, const std::wstring &domain) {
+  std::wstring name = WithoutTrailingDot(fullName);
+  std::wstring suffix = Lower(L"." + regType + L"." + domain);
+  if (EndsWith(Lower(name), suffix)) {
+    return name.substr(0, name.size() - suffix.size());
+  }
+  size_t typeStart = name.find(L"._");
+  return typeStart == std::wstring::npos ? name : name.substr(0, typeStart);
+}
+
+// TXT strings or SRV target and port, to notice changes
+std::wstring RecordData(const DNS_RECORD &record) {
+  std::wstring data;
+  if (record.wType == DNS_TYPE_TEXT) {
+    for (DWORD i = 0; i < record.Data.TXT.dwStringCount; i++) {
+      data += std::wstring(record.Data.TXT.pStringArray[i] ? record.Data.TXT.pStringArray[i] : L"") + L'\n';
+    }
+  } else if (record.wType == DNS_TYPE_SRV) {
+    data = std::wstring(record.Data.SRV.pNameTarget ? record.Data.SRV.pNameTarget : L"") + L":" + std::to_wstring(record.Data.SRV.wPort);
+  }
+  return data;
+}
+
+// "_http._tcp.local" -> "_http._tcp"
+std::wstring ServiceTypeName(const std::wstring &target) {
+  size_t first = target.find(L'.');
+  if (first == std::wstring::npos) {
+    return target;
+  }
+  size_t second = target.find(L'.', first + 1);
+  return second == std::wstring::npos ? target : target.substr(0, second);
+}
+
+Error WindowsError(DWORD status, const std::wstring &prefix, const std::wstring &serviceName) {
+  Error error;
+  error.domain = L"Windows";
+  error.code = static_cast<int64_t>(status);
+  error.message = prefix + DescribeStatus(status);
+  error.serviceName = serviceName;
+  return error;
+}
+
+Error LibraryError(const std::wstring &code, const std::wstring &message, const std::wstring &serviceName) {
+  Error error;
+  error.domain = L"RNZeroconf";
+  error.stringCode = code;
+  error.message = message;
+  error.serviceName = serviceName;
+  return error;
+}
+
+std::wstring AddressString(int family, const void *address) {
+  wchar_t buffer[INET6_ADDRSTRLEN] = {};
+  return InetNtopW(family, address, buffer, INET6_ADDRSTRLEN) ? std::wstring(buffer) : std::wstring();
+}
+
+void Run(After &after) {
+  for (auto &action : after) {
+    action();
+  }
+  after.clear();
+}
+
+VOID WINAPI BrowseCallback(DWORD status, PVOID context, PDNS_RECORD records) {
+  auto browse = Tracked<Browse>(context);
+  if (!browse) {
+    if (records) {
+      DnsRecordListFree(records, DnsFreeRecordList);
+    }
+    return;
+  }
+  browse->owner->OnBrowse(browse, status, records);
+}
+
+VOID WINAPI ResolveCallback(DWORD status, PVOID context, PDNS_SERVICE_INSTANCE instance) {
+  auto resolve = Tracked<Resolve>(context);
+  if (!resolve) {
+    if (instance) {
+      DnsServiceFreeInstance(instance);
+    }
+    return;
+  }
+  resolve->owner->OnResolve(resolve, status, instance);
+}
+
+VOID WINAPI RegisterCallback(DWORD status, PVOID context, PDNS_SERVICE_INSTANCE instance) {
+  auto publication = Tracked<Publication>(context);
+  if (!publication) {
+    if (instance) {
+      DnsServiceFreeInstance(instance);
+    }
+    return;
+  }
+  publication->owner->OnRegister(publication, status, instance);
+}
+
+} // namespace
+
+std::wstring Widen(const std::string &value) {
+  if (value.empty()) {
+    return std::wstring();
+  }
+  int size = MultiByteToWideChar(CP_UTF8, 0, value.data(), static_cast<int>(value.size()), nullptr, 0);
+  std::wstring result(size, L'\0');
+  MultiByteToWideChar(CP_UTF8, 0, value.data(), static_cast<int>(value.size()), &result[0], size);
+  return result;
+}
+
+std::string Narrow(const std::wstring &value) {
+  if (value.empty()) {
+    return std::string();
+  }
+  int size = WideCharToMultiByte(CP_UTF8, 0, value.data(), static_cast<int>(value.size()), nullptr, 0, nullptr, nullptr);
+  std::string result(size, '\0');
+  WideCharToMultiByte(CP_UTF8, 0, value.data(), static_cast<int>(value.size()), &result[0], size, nullptr, nullptr);
+  return result;
+}
+
+std::wstring DescribeStatus(DWORD status) {
+  wchar_t *buffer = nullptr;
+  DWORD length = FormatMessageW(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+      nullptr,
+      status,
+      0,
+      reinterpret_cast<LPWSTR>(&buffer),
+      0,
+      nullptr);
+  std::wstring message = length && buffer ? std::wstring(buffer, length) : L"error " + std::to_wstring(status);
+  if (buffer) {
+    LocalFree(buffer);
+  }
+  while (!message.empty() && (message.back() == L'\n' || message.back() == L'\r' || message.back() == L'.' || message.back() == L' ')) {
+    message.pop_back();
+  }
+  return message;
+}
+
+Zeroconf::Zeroconf(Events events) : events_(std::move(events)), alive_(std::make_shared<std::atomic<bool>>(true)) {
+  wchar_t name[256] = {};
+  DWORD size = 256;
+  if (GetComputerNameExW(ComputerNameDnsHostname, name, &size) && size > 0) {
+    hostName_ = std::wstring(name, size) + L".local";
+  } else {
+    hostName_ = L"windows.local";
+  }
+}
+
+Zeroconf::~Zeroconf() {
+  *alive_ = false;
+  StopAll();
+  UnpublishAll();
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    for (auto &resolve : singleResolves_) {
+      CancelResolve(resolve, after);
+    }
+    singleResolves_.clear();
+  }
+  Run(after);
+  // Late callbacks of deregistrations still in flight are ignored
+  std::lock_guard<std::mutex> lock(registryMutex);
+  for (auto &entry : Registry()) {
+    if (entry.second->owner == this) {
+      entry.second->owner = nullptr;
+    }
+  }
+}
+
+bool Zeroconf::InterfaceIndex(const std::wstring &networkInterface, ULONG &index, Error &error) const {
+  index = 0;
+  if (networkInterface.empty()) {
+    return true;
+  }
+  if (std::all_of(networkInterface.begin(), networkInterface.end(), [](wchar_t c) { return std::iswdigit(c); })) {
+    index = std::wcstoul(networkInterface.c_str(), nullptr, 10);
+    return true;
+  }
+  // By friendly name ("Wi-Fi", "Ethernet") or adapter name
+  ULONG size = 16 * 1024;
+  std::vector<BYTE> buffer(size);
+  ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
+  ULONG result = GetAdaptersAddresses(AF_UNSPEC, flags, nullptr, reinterpret_cast<PIP_ADAPTER_ADDRESSES>(buffer.data()), &size);
+  if (result == ERROR_BUFFER_OVERFLOW) {
+    buffer.resize(size);
+    result = GetAdaptersAddresses(AF_UNSPEC, flags, nullptr, reinterpret_cast<PIP_ADAPTER_ADDRESSES>(buffer.data()), &size);
+  }
+  if (result == NO_ERROR) {
+    std::wstring wanted = Lower(networkInterface);
+    for (auto adapter = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(buffer.data()); adapter; adapter = adapter->Next) {
+      bool friendly = adapter->FriendlyName && Lower(adapter->FriendlyName) == wanted;
+      bool adapterName = adapter->AdapterName && Lower(Widen(adapter->AdapterName)) == wanted;
+      if (friendly || adapterName) {
+        index = adapter->IfIndex ? adapter->IfIndex : adapter->Ipv6IfIndex;
+        return true;
+      }
+    }
+  }
+  error = LibraryError(L"UNKNOWN_INTERFACE", L"Unknown network interface " + networkInterface, L"");
+  return false;
+}
+
+// Scan
+
+void Zeroconf::Scan(
+    const std::string &scanId,
+    const std::wstring &type,
+    const std::wstring &protocol,
+    const std::wstring &domain,
+    const std::wstring &subtype,
+    const std::wstring &networkInterface,
+    double resolveTimeoutSeconds) {
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    StopLocked(scanId, after);
+
+    auto browse = std::make_shared<Browse>(this);
+    browse->scanId = scanId;
+    browse->resolveTimeoutMs = static_cast<DWORD>((resolveTimeoutSeconds > 0 ? resolveTimeoutSeconds : 5) * 1000);
+    browse->regType = L"_" + type + L"._" + protocol;
+    browse->domain = DomainName(domain);
+    browse->typesOnly = type == L"services._dns-sd" && protocol == L"udp";
+    Error interfaceError;
+    if (!InterfaceIndex(networkInterface, browse->interfaceIndex, interfaceError)) {
+      after.push_back([this, scanId, interfaceError] {
+        if (events_.error) events_.error(scanId, interfaceError);
+      });
+    } else {
+      // "_printer._sub._ipp._tcp.local" browses the _printer subtype
+      browse->queryName = (subtype.empty() ? L"" : Label(subtype) + L"._sub.") + browse->regType + L"." + browse->domain;
+      browse->request.Version = DNS_QUERY_REQUEST_VERSION1;
+      browse->request.InterfaceIndex = browse->interfaceIndex;
+      browse->request.QueryName = browse->queryName.c_str();
+      browse->request.pBrowseCallback = BrowseCallback;
+      browse->request.pQueryContext = browse.get();
+      Track(browse);
+      DNS_STATUS status = DnsServiceBrowse(&browse->request, &browse->cancel);
+      if (status != DNS_REQUEST_PENDING) {
+        Untrack(browse.get());
+        Error error = WindowsError(status, L"Browsing services failed: ", L"");
+        after.push_back([this, scanId, error] {
+          if (events_.error) events_.error(scanId, error);
+        });
+      } else {
+        browses_[scanId] = browse;
+        after.push_back([this, scanId] {
+          if (events_.start) events_.start(scanId);
+        });
+        if (browse->typesOnly) {
+          for (auto &entry : publications_) {
+            SyncLocalType(entry.second->regType, entry.second->domain, after);
+          }
+        }
+      }
+    }
+  }
+  Run(after);
+}
+
+void Zeroconf::Stop(const std::string &scanId) {
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    StopLocked(scanId, after);
+  }
+  Run(after);
+}
+
+void Zeroconf::StopAll() {
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    std::vector<std::string> scanIds;
+    for (auto &entry : browses_) {
+      scanIds.push_back(entry.first);
+    }
+    for (auto &scanId : scanIds) {
+      StopLocked(scanId, after);
+    }
+  }
+  Run(after);
+}
+
+void Zeroconf::StopLocked(const std::string &scanId, After &after) {
+  auto it = browses_.find(scanId);
+  if (it == browses_.end()) {
+    return;
+  }
+  auto browse = it->second;
+  browses_.erase(it);
+  Untrack(browse.get());
+  for (auto &entry : browse->resolves) {
+    CancelResolve(entry.second, after);
+  }
+  browse->resolves.clear();
+  // Cancelling outside the lock, a callback in flight may be waiting for it
+  after.push_back([this, browse, scanId] {
+    DnsServiceBrowseCancel(&browse->cancel);
+    if (events_.stop) events_.stop(scanId);
+  });
+}
+
+void Zeroconf::OnBrowse(const std::shared_ptr<Browse> &browse, DWORD status, PDNS_RECORD records) {
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    auto current = browses_.find(browse->scanId);
+    if (current != browses_.end() && current->second == browse) {
+      if (status != ERROR_SUCCESS && status != ERROR_CANCELLED) {
+        Error error = WindowsError(status, L"Browsing services failed: ", L"");
+        std::string scanId = browse->scanId;
+        after.push_back([this, scanId, error] {
+          if (events_.error) events_.error(scanId, error);
+        });
+      }
+      for (PDNS_RECORD record = records; record; record = record->pNext) {
+        if (DebugEnabled()) {
+          fwprintf(stderr, L"[browse %hs] status=%lu type=%u ttl=%lu name=%ls target=%ls\n", browse->scanId.c_str(), status,
+                   record->wType, record->dwTtl, record->pName ? record->pName : L"",
+                   record->wType == DNS_TYPE_PTR && record->Data.PTR.pNameHost ? record->Data.PTR.pNameHost : L"");
+        }
+        // Live updates: a resolved service whose TXT or SRV record changes is resolved again
+        if (!browse->typesOnly && (record->wType == DNS_TYPE_TEXT || record->wType == DNS_TYPE_SRV) && record->pName && record->dwTtl > 0) {
+          std::wstring instanceKey = Lower(WithoutTrailingDot(record->pName));
+          std::wstring dataKey = instanceKey + (record->wType == DNS_TYPE_TEXT ? L"#txt" : L"#srv");
+          std::wstring data = RecordData(*record);
+          auto previous = browse->recordData.find(dataKey);
+          bool changed = previous != browse->recordData.end() && previous->second != data;
+          browse->recordData[dataKey] = data;
+          auto foundInstance = browse->found.find(instanceKey);
+          if (changed && foundInstance != browse->found.end() && browse->resolved.count(instanceKey) && !browse->resolves.count(instanceKey)) {
+            auto resolve = std::make_shared<Resolve>(this);
+            resolve->browse = browse;
+            resolve->scanId = browse->scanId;
+            resolve->name = foundInstance->second;
+            resolve->key = instanceKey;
+            resolve->queryName = WithoutTrailingDot(record->pName);
+            resolve->interfaceIndex = browse->interfaceIndex;
+            browse->resolves[instanceKey] = resolve;
+            StartScanResolve(browse, resolve, after);
+          }
+          continue;
+        }
+        if (record->wType != DNS_TYPE_PTR || !record->Data.PTR.pNameHost) {
+          continue;
+        }
+        std::wstring target = WithoutTrailingDot(record->Data.PTR.pNameHost);
+        std::wstring key = Lower(target);
+        auto found = browse->found.find(key);
+        std::string scanId = browse->scanId;
+
+        // A zero TTL is a goodbye: the service left
+        if (record->dwTtl == 0) {
+          if (browse->typesOnly) {
+            browse->networkTypes.erase(key);
+            // Still listed while this app publishes it
+            if (LocallyPublished(key)) {
+              continue;
+            }
+          }
+          if (found != browse->found.end()) {
+            std::wstring name = found->second;
+            browse->found.erase(found);
+            auto resolve = browse->resolves.find(key);
+            if (resolve != browse->resolves.end()) {
+              CancelResolve(resolve->second, after);
+              browse->resolves.erase(resolve);
+            }
+            browse->resolved.erase(key);
+            after.push_back([this, scanId, name] {
+              if (events_.remove) events_.remove(scanId, name);
+            });
+          }
+          continue;
+        }
+        if (browse->typesOnly) {
+          browse->networkTypes.insert(key);
+        }
+        if (found != browse->found.end()) {
+          continue;
+        }
+
+        std::wstring name = browse->typesOnly ? ServiceTypeName(target) : InstanceName(target, browse->regType, browse->domain);
+        // Service type answers can also announce subtypes ("_printer._sub._ipp._tcp"), only types are listed
+        if (browse->typesOnly && !EndsWith(Lower(name), L"._tcp") && !EndsWith(Lower(name), L"._udp")) {
+          continue;
+        }
+        browse->found[key] = name;
+        after.push_back([this, scanId, name] {
+          if (events_.found) events_.found(scanId, name);
+        });
+        // Service types are not resolved
+        if (!browse->typesOnly) {
+          auto resolve = std::make_shared<Resolve>(this);
+          resolve->browse = browse;
+          resolve->scanId = scanId;
+          resolve->name = name;
+          resolve->key = key;
+          resolve->queryName = target;
+          resolve->interfaceIndex = browse->interfaceIndex;
+          browse->resolves[key] = resolve;
+          StartScanResolve(browse, resolve, after);
+        }
+      }
+    }
+  }
+  if (records) {
+    DnsRecordListFree(records, DnsFreeRecordList);
+  }
+  Run(after);
+}
+
+// Resolve
+
+void Zeroconf::StartResolve(const std::shared_ptr<Resolve> &resolve, After &after) {
+  resolve->request.Version = DNS_QUERY_REQUEST_VERSION1;
+  resolve->request.InterfaceIndex = resolve->interfaceIndex;
+  resolve->request.QueryName = &resolve->queryName[0];
+  resolve->request.pResolveCompletionCallback = ResolveCallback;
+  resolve->request.pQueryContext = resolve.get();
+  Track(resolve);
+  DNS_STATUS status = DnsServiceResolve(&resolve->request, &resolve->cancel);
+  if (status == DNS_REQUEST_PENDING) {
+    return;
+  }
+  Untrack(resolve.get());
+  resolve->done = true;
+  Error error = WindowsError(status, L"Resolving service " + resolve->name + L" failed: ", resolve->name);
+  if (resolve->promiseReject) {
+    auto reject = resolve->promiseReject;
+    after.push_back([reject, error] { reject(error); });
+    return;
+  }
+  std::string scanId = resolve->scanId;
+  after.push_back([this, scanId, error] {
+    if (events_.error) events_.error(scanId, error);
+  });
+}
+
+// Resolves of a scan time out after the scan's resolveTimeout, are retried once, then reported with a TIMEOUT error
+void Zeroconf::StartScanResolve(const std::shared_ptr<Browse> &browse, const std::shared_ptr<Resolve> &resolve, After &after) {
+  StartResolve(resolve, after);
+  if (resolve->done) {
+    return;
+  }
+  std::weak_ptr<Resolve> weak = resolve;
+  auto alive = alive_;
+  DWORD timeout = browse->resolveTimeoutMs;
+  std::thread([this, weak, alive, timeout] {
+    Sleep(timeout);
+    if (!*alive) return;
+    auto expired = weak.lock();
+    if (!expired) return;
+    After timedOut;
+    {
+      std::lock_guard<std::recursive_mutex> lock(mutex_);
+      auto browse = expired->browse.lock();
+      auto current = browse ? browses_.find(browse->scanId) : browses_.end();
+      if (expired->done || current == browses_.end() || current->second != browse) return;
+      auto entry = browse->resolves.find(expired->key);
+      if (entry == browse->resolves.end() || entry->second != expired) return;
+      CancelResolve(expired, timedOut);
+      browse->resolves.erase(entry);
+      if (!expired->retried) {
+        // Slow devices can time out, retry once before reporting the error
+        auto retry = std::make_shared<Resolve>(this);
+        retry->browse = browse;
+        retry->scanId = expired->scanId;
+        retry->name = expired->name;
+        retry->key = expired->key;
+        retry->queryName = expired->queryName;
+        retry->interfaceIndex = expired->interfaceIndex;
+        retry->retried = true;
+        browse->resolves[retry->key] = retry;
+        StartScanResolve(browse, retry, timedOut);
+      } else {
+        Error error = LibraryError(L"TIMEOUT", L"Resolving service " + expired->name + L" failed: timed out", expired->name);
+        std::string scanId = expired->scanId;
+        timedOut.push_back([this, scanId, error] {
+          if (events_.error) events_.error(scanId, error);
+        });
+      }
+    }
+    Run(timedOut);
+  }).detach();
+}
+
+void Zeroconf::CancelResolve(const std::shared_ptr<Resolve> &resolve, After &after) {
+  if (resolve->done) {
+    return;
+  }
+  resolve->done = true;
+  Untrack(resolve.get());
+  after.push_back([resolve] { DnsServiceResolveCancel(&resolve->cancel); });
+}
+
+void Zeroconf::OnResolve(const std::shared_ptr<Resolve> &resolve, DWORD status, PDNS_SERVICE_INSTANCE instance) {
+  Service service;
+  bool resolved = status == ERROR_SUCCESS && instance != nullptr;
+  if (resolved) {
+    service.name = resolve->name;
+    service.fullName = instance->pszInstanceName ? instance->pszInstanceName : resolve->queryName;
+    service.host = instance->pszHostName ? instance->pszHostName : L"";
+    service.port = instance->wPort;
+    if (instance->ip4Address) {
+      IN_ADDR address{};
+      address.S_un.S_addr = *instance->ip4Address;
+      std::wstring text = AddressString(AF_INET, &address);
+      if (!text.empty()) service.addresses.push_back(text);
+    }
+    if (instance->ip6Address) {
+      IN6_ADDR address{};
+      memcpy(&address, instance->ip6Address->IP6Byte, sizeof(address));
+      std::wstring text = AddressString(AF_INET6, &address);
+      if (!text.empty()) service.addresses.push_back(text);
+    }
+    for (DWORD i = 0; i < instance->dwPropertyCount; i++) {
+      if (instance->keys && instance->keys[i]) {
+        service.txt.emplace_back(instance->keys[i], instance->values && instance->values[i] ? instance->values[i] : L"");
+      }
+    }
+  }
+  if (DebugEnabled()) {
+    fwprintf(stderr, L"[resolve %ls] status=%lu host=%ls port=%u addresses=%zu txt=%zu\n", resolve->name.c_str(), status,
+             service.host.c_str(), service.port, service.addresses.size(), service.txt.size());
+  }
+  if (instance) {
+    DnsServiceFreeInstance(instance);
+  }
+
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    Untrack(resolve.get());
+    if (resolve->done) {
+      return;
+    }
+    resolve->done = true;
+    Error error = WindowsError(status, L"Resolving service " + resolve->name + L" failed: ", resolve->name);
+
+    if (resolve->promiseResolve) {
+      singleResolves_.erase(std::remove(singleResolves_.begin(), singleResolves_.end(), resolve), singleResolves_.end());
+      auto promiseResolve = resolve->promiseResolve;
+      auto promiseReject = resolve->promiseReject;
+      after.push_back([resolved, service, error, promiseResolve, promiseReject] {
+        if (resolved) {
+          promiseResolve(service);
+        } else {
+          promiseReject(error);
+        }
+      });
+    } else {
+      auto browse = resolve->browse.lock();
+      auto current = browse ? browses_.find(browse->scanId) : browses_.end();
+      if (current == browses_.end() || current->second != browse) {
+        return;
+      }
+      auto entry = browse->resolves.find(resolve->key);
+      if (entry == browse->resolves.end() || entry->second != resolve) {
+        return;
+      }
+      browse->resolves.erase(entry);
+      if (resolved) {
+        browse->resolved.insert(resolve->key);
+      }
+      std::string scanId = resolve->scanId;
+      after.push_back([this, resolved, service, error, scanId] {
+        if (resolved) {
+          if (events_.resolved) events_.resolved(scanId, service);
+        } else if (events_.error) {
+          events_.error(scanId, error);
+        }
+      });
+    }
+  }
+  Run(after);
+}
+
+void Zeroconf::ResolveService(
+    const std::wstring &name,
+    const std::wstring &type,
+    const std::wstring &protocol,
+    const std::wstring &domain,
+    const std::wstring &networkInterface,
+    double timeoutSeconds,
+    ServiceCallback resolve,
+    ErrorCallback reject) {
+  After after;
+  std::shared_ptr<Resolve> single;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    single = std::make_shared<Resolve>(this);
+    Error interfaceError;
+    if (!InterfaceIndex(networkInterface, single->interfaceIndex, interfaceError)) {
+      after.push_back([reject, interfaceError] { reject(interfaceError); });
+      single = nullptr;
+    } else {
+      single->name = name;
+      single->queryName = name + L"._" + type + L"._" + protocol + L"." + DomainName(domain);
+      single->promiseResolve = std::move(resolve);
+      single->promiseReject = std::move(reject);
+      singleResolves_.push_back(single);
+      StartResolve(single, after);
+    }
+  }
+  Run(after);
+  if (!single) {
+    return;
+  }
+
+  std::weak_ptr<Resolve> weak = single;
+  auto alive = alive_;
+  DWORD timeout = static_cast<DWORD>((timeoutSeconds > 0 ? timeoutSeconds : 5) * 1000);
+  std::thread([this, weak, alive, timeout] {
+    Sleep(timeout);
+    if (!*alive) return;
+    auto expired = weak.lock();
+    if (!expired) return;
+    After timedOut;
+    {
+      std::lock_guard<std::recursive_mutex> lock(mutex_);
+      if (expired->done) return;
+      CancelResolve(expired, timedOut);
+      singleResolves_.erase(std::remove(singleResolves_.begin(), singleResolves_.end(), expired), singleResolves_.end());
+      Error error = LibraryError(L"TIMEOUT", L"Resolving service " + expired->name + L" failed: timed out", expired->name);
+      auto reject = expired->promiseReject;
+      timedOut.push_back([reject, error] { reject(error); });
+    }
+    Run(timedOut);
+  }).detach();
+}
+
+// Publish
+
+void Zeroconf::Publish(
+    const std::wstring &type,
+    const std::wstring &protocol,
+    const std::wstring &domain,
+    const std::wstring &name,
+    uint16_t port,
+    const TxtPairs &txt,
+    const std::wstring &networkInterface,
+    ServiceCallback resolve,
+    ErrorCallback reject) {
+  ULONG interfaceIndex = 0;
+  Error interfaceError;
+  if (!InterfaceIndex(networkInterface, interfaceIndex, interfaceError)) {
+    interfaceError.serviceName = name;
+    if (events_.error) events_.error("", interfaceError);
+    reject(interfaceError);
+    return;
+  }
+  PublishAs(L"_" + type + L"._" + protocol, DomainName(domain), name, port, txt, interfaceIndex, true, std::move(resolve), std::move(reject));
+}
+
+void Zeroconf::PublishAs(
+    const std::wstring &regType,
+    const std::wstring &domain,
+    const std::wstring &requestedName,
+    uint16_t port,
+    const TxtPairs &txt,
+    ULONG interfaceIndex,
+    bool announce,
+    ServiceCallback resolve,
+    ErrorCallback reject) {
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    // The same app can't publish a name twice, rename like Bonjour does on conflicts
+    std::wstring name = requestedName;
+    for (int suffix = 2; publications_.count(name); suffix++) {
+      name = requestedName + L" (" + std::to_wstring(suffix) + L")";
+    }
+
+    auto publication = std::make_shared<Publication>(this);
+    publication->requestedName = name;
+    publication->name = name;
+    publication->regType = regType;
+    publication->domain = domain;
+    publication->port = port;
+    publication->txt = txt;
+    publication->interfaceIndex = interfaceIndex;
+    publication->announce = announce;
+    publication->onRegistered = std::move(resolve);
+    publication->onRegisterFailed = std::move(reject);
+
+    std::vector<PCWSTR> keys;
+    std::vector<PCWSTR> values;
+    for (auto &pair : publication->txt) {
+      keys.push_back(pair.first.c_str());
+      values.push_back(pair.second.c_str());
+    }
+    std::wstring fullName = name + L"." + regType + L"." + domain;
+    publication->instance = DnsServiceConstructInstance(
+        fullName.c_str(),
+        hostName_.c_str(),
+        nullptr,
+        nullptr,
+        port,
+        0,
+        0,
+        static_cast<DWORD>(keys.size()),
+        keys.empty() ? nullptr : keys.data(),
+        values.empty() ? nullptr : values.data());
+    DNS_STATUS status = publication->instance ? DNS_REQUEST_PENDING : GetLastError();
+    if (publication->instance) {
+      publication->request.Version = DNS_QUERY_REQUEST_VERSION1;
+      publication->request.InterfaceIndex = interfaceIndex;
+      publication->request.pServiceInstance = publication->instance;
+      publication->request.pRegisterCompletionCallback = RegisterCallback;
+      publication->request.pQueryContext = publication.get();
+      publication->request.hCredentials = nullptr;
+      publication->request.unicastEnabled = FALSE;
+      Track(publication);
+      status = DnsServiceRegister(&publication->request, &publication->cancel);
+    }
+    if (status == DNS_REQUEST_PENDING) {
+      publications_[name] = publication;
+    } else {
+      Untrack(publication.get());
+      Error error = WindowsError(status, L"Publishing service " + name + L" failed: ", name);
+      auto onFailed = publication->onRegisterFailed;
+      after.push_back([this, error, onFailed] {
+        if (events_.error) events_.error("", error);
+        if (onFailed) onFailed(error);
+      });
+    }
+  }
+  Run(after);
+}
+
+void Zeroconf::OnRegister(const std::shared_ptr<Publication> &publication, DWORD status, PDNS_SERVICE_INSTANCE instance) {
+  std::wstring registeredName = publication->name;
+  if (instance && instance->pszInstanceName) {
+    registeredName = InstanceName(instance->pszInstanceName, publication->regType, publication->domain);
+  }
+  if (DebugEnabled()) {
+    fwprintf(stderr, L"[register %ls] status=%lu state=%d name=%ls\n", publication->requestedName.c_str(), status,
+             static_cast<int>(publication->state), registeredName.c_str());
+  }
+  if (instance && instance != publication->instance) {
+    DnsServiceFreeInstance(instance);
+  }
+
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if (publication->state == Publication::State::Registering) {
+      auto entry = publications_.find(publication->name);
+      bool current = entry != publications_.end() && entry->second == publication;
+      if (status != ERROR_SUCCESS) {
+        Untrack(publication.get());
+        publication->state = Publication::State::Done;
+        if (current) publications_.erase(entry);
+        Error error = WindowsError(status, L"Publishing service " + publication->name + L" failed: ", publication->name);
+        auto onFailed = publication->onRegisterFailed;
+        after.push_back([this, error, onFailed] {
+          if (events_.error) events_.error("", error);
+          if (onFailed) onFailed(error);
+        });
+      } else {
+        publication->state = Publication::State::Registered;
+        if (current && registeredName != publication->name) {
+          publications_.erase(entry);
+          publications_[registeredName] = publication;
+        }
+        publication->name = registeredName;
+        SyncLocalType(publication->regType, publication->domain, after);
+        Service service = PublishedService(*publication);
+        auto onRegistered = publication->onRegistered;
+        bool announce = publication->announce;
+        after.push_back([this, service, onRegistered, announce] {
+          if (announce && events_.published) events_.published(service);
+          if (onRegistered) onRegistered(service);
+        });
+      }
+      publication->onRegistered = nullptr;
+      publication->onRegisterFailed = nullptr;
+    } else if (publication->state == Publication::State::Deregistering) {
+      publication->state = Publication::State::Done;
+      Untrack(publication.get());
+      // An update publishes it again right after, keep the type listed
+      if (publication->announce) {
+        SyncLocalType(publication->regType, publication->domain, after);
+      }
+      Service service = PublishedService(*publication);
+      auto onDeregistered = publication->onDeregistered;
+      bool announce = publication->announce;
+      after.push_back([this, service, onDeregistered, announce] {
+        if (announce && events_.unpublished) events_.unpublished(service);
+        if (onDeregistered) onDeregistered(service);
+      });
+      publication->onDeregistered = nullptr;
+    }
+  }
+  Run(after);
+}
+
+bool Zeroconf::LocallyPublished(const std::wstring &typeKey) const {
+  for (auto &entry : publications_) {
+    auto &publication = entry.second;
+    if (publication->state == Publication::State::Registered && Lower(publication->regType + L"." + publication->domain) == typeKey) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void Zeroconf::SyncLocalType(const std::wstring &regType, const std::wstring &domain, After &after) {
+  std::wstring key = Lower(regType + L"." + domain);
+  bool published = LocallyPublished(key);
+  for (auto &entry : browses_) {
+    auto browse = entry.second;
+    if (!browse->typesOnly || Lower(browse->domain) != Lower(domain)) {
+      continue;
+    }
+    std::string scanId = browse->scanId;
+    auto listed = browse->found.find(key);
+    if (published && listed == browse->found.end()) {
+      browse->found[key] = regType;
+      after.push_back([this, scanId, regType] {
+        if (events_.found) events_.found(scanId, regType);
+      });
+    } else if (!published && listed != browse->found.end() && !browse->networkTypes.count(key)) {
+      std::wstring name = listed->second;
+      browse->found.erase(listed);
+      after.push_back([this, scanId, name] {
+        if (events_.remove) events_.remove(scanId, name);
+      });
+    }
+  }
+}
+
+Service Zeroconf::PublishedService(const Publication &publication) const {
+  Service service;
+  service.name = publication.name;
+  service.fullName = publication.name + L"." + publication.regType + L"." + publication.domain;
+  service.host = hostName_;
+  service.port = publication.port;
+  service.txt = publication.txt;
+  return service;
+}
+
+void Zeroconf::Unpublish(const std::wstring &name, ServiceCallback resolve, ErrorCallback reject) {
+  UnpublishWith(name, true, std::move(resolve), std::move(reject));
+}
+
+void Zeroconf::UnpublishWith(const std::wstring &name, bool announce, ServiceCallback resolve, ErrorCallback reject) {
+  After after;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    auto entry = publications_.find(name);
+    if (entry == publications_.end()) {
+      for (auto it = publications_.begin(); it != publications_.end(); ++it) {
+        if (it->second->requestedName == name) {
+          entry = it;
+          break;
+        }
+      }
+    }
+    if (entry == publications_.end()) {
+      Error error = LibraryError(L"NOT_PUBLISHED", L"Service " + name + L" is not published", name);
+      after.push_back([reject, error] { reject(error); });
+    } else {
+      auto publication = entry->second;
+      publications_.erase(entry);
+      if (publication->state == Publication::State::Registering) {
+        // Not registered yet: cancel the registration
+        publication->state = Publication::State::Done;
+        Untrack(publication.get());
+        Error error = LibraryError(L"NOT_PUBLISHED", L"Service " + name + L" was unpublished before it was published", name);
+        auto onFailed = publication->onRegisterFailed;
+        Service service = PublishedService(*publication);
+        after.push_back([publication, onFailed, error, resolve, service] {
+          DnsServiceRegisterCancel(&publication->cancel);
+          if (onFailed) onFailed(error);
+          resolve(service);
+        });
+      } else {
+        publication->state = Publication::State::Deregistering;
+        publication->announce = announce;
+        publication->onDeregistered = std::move(resolve);
+        after.push_back([this, publication, reject] {
+          DWORD status = DnsServiceDeRegister(&publication->request, nullptr);
+          if (status != DNS_REQUEST_PENDING) {
+            Untrack(publication.get());
+            reject(WindowsError(status, L"Unpublishing service " + publication->name + L" failed: ", publication->name));
+          }
+        });
+      }
+    }
+  }
+  Run(after);
+}
+
+void Zeroconf::Update(const std::wstring &name, const TxtPairs &txt, ServiceCallback resolve, ErrorCallback reject) {
+  std::shared_ptr<Publication> publication;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    auto entry = publications_.find(name);
+    if (entry != publications_.end() && entry->second->state == Publication::State::Registered) {
+      publication = entry->second;
+    }
+  }
+  if (!publication) {
+    reject(LibraryError(L"NOT_PUBLISHED", L"Service " + name + L" is not published", name));
+    return;
+  }
+  // No update in windns.h: unpublish, then publish again under the same name
+  std::wstring regType = publication->regType;
+  std::wstring domain = publication->domain;
+  std::wstring registeredName = publication->name;
+  uint16_t port = publication->port;
+  ULONG interfaceIndex = publication->interfaceIndex;
+  UnpublishWith(
+      name,
+      false,
+      [this, regType, domain, registeredName, port, txt, interfaceIndex, resolve, reject](const Service &) {
+        PublishAs(regType, domain, registeredName, port, txt, interfaceIndex, false, resolve, reject);
+      },
+      reject);
+}
+
+void Zeroconf::UnpublishAll() {
+  std::vector<std::wstring> names;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    for (auto &entry : publications_) {
+      names.push_back(entry.first);
+    }
+  }
+  for (auto &name : names) {
+    Unpublish(name, [](const Service &) {}, [](const Error &) {});
+  }
+}
+
+} // namespace rnzeroconf