blob: 2a1873072fbb9e8235f8bc775e1471a9520f2542 [file] [log] [blame]
/*
*
* Copyright (c) 2020-2022 Project CHIP Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "DnssdImpl.h"
#include <algorithm>
#include <sstream>
#include <string.h>
#include <time.h>
#include <vector>
#include <netinet/in.h>
#include <lib/support/CHIPMem.h>
#include <lib/support/CHIPMemString.h>
#include <lib/support/CodeUtils.h>
#include <platform/internal/CHIPDeviceLayerInternal.h>
#include <system/SystemLayer.h>
using chip::Dnssd::DnssdServiceProtocol;
using chip::Dnssd::kDnssdTypeMaxSize;
using chip::Dnssd::TextEntry;
using chip::System::SocketEvents;
using std::chrono::duration_cast;
using std::chrono::microseconds;
using std::chrono::seconds;
using std::chrono::steady_clock;
namespace {
AvahiProtocol ToAvahiProtocol(chip::Inet::IPAddressType addressType)
{
#if INET_CONFIG_ENABLE_IPV4
AvahiProtocol protocol;
switch (addressType)
{
case chip::Inet::IPAddressType::kIPv4:
protocol = AVAHI_PROTO_INET;
break;
case chip::Inet::IPAddressType::kIPv6:
protocol = AVAHI_PROTO_INET6;
break;
default:
protocol = AVAHI_PROTO_UNSPEC;
break;
}
return protocol;
#else
// We only support IPV6, never tell AVAHI about INET4 or UNSPEC because
// UNSPEC may actually return IPv4 data.
return AVAHI_PROTO_INET6;
#endif
}
chip::Inet::IPAddressType ToAddressType(AvahiProtocol protocol)
{
chip::Inet::IPAddressType type;
switch (protocol)
{
#if INET_CONFIG_ENABLE_IPV4
case AVAHI_PROTO_INET:
type = chip::Inet::IPAddressType::kIPv4;
break;
#endif
case AVAHI_PROTO_INET6:
type = chip::Inet::IPAddressType::kIPv6;
break;
default:
type = chip::Inet::IPAddressType::kUnknown;
break;
}
return type;
}
AvahiWatchEvent ToAvahiWatchEvent(SocketEvents events)
{
return static_cast<AvahiWatchEvent>((events.Has(chip::System::SocketEventFlags::kRead) ? AVAHI_WATCH_IN : 0) |
(events.Has(chip::System::SocketEventFlags::kWrite) ? AVAHI_WATCH_OUT : 0) |
(events.Has(chip::System::SocketEventFlags::kError) ? AVAHI_WATCH_ERR : 0));
}
void AvahiWatchCallbackTrampoline(chip::System::SocketEvents events, intptr_t data)
{
AvahiWatch * const watch = reinterpret_cast<AvahiWatch *>(data);
watch->mPendingIO = ToAvahiWatchEvent(events);
watch->mCallback(watch, watch->mSocket, watch->mPendingIO, watch->mContext);
}
CHIP_ERROR MakeAvahiStringListFromTextEntries(TextEntry * entries, size_t size, AvahiStringList ** strListOut)
{
*strListOut = avahi_string_list_new(nullptr, nullptr);
for (size_t i = 0; i < size; i++)
{
uint8_t buf[chip::Dnssd::kDnssdTextMaxSize];
size_t offset = static_cast<size_t>(snprintf(reinterpret_cast<char *>(buf), sizeof(buf), "%s=", entries[i].mKey));
if (offset + entries[i].mDataSize > sizeof(buf))
{
avahi_string_list_free(*strListOut);
*strListOut = nullptr;
return CHIP_ERROR_INVALID_ARGUMENT;
}
memcpy(&buf[offset], entries[i].mData, entries[i].mDataSize);
*strListOut = avahi_string_list_add_arbitrary(*strListOut, buf, offset + entries[i].mDataSize);
}
return CHIP_NO_ERROR;
}
const char * GetProtocolString(DnssdServiceProtocol protocol)
{
return protocol == DnssdServiceProtocol::kDnssdProtocolUdp ? "_udp" : "_tcp";
}
std::string GetFullType(const char * type, DnssdServiceProtocol protocol)
{
std::ostringstream typeBuilder;
typeBuilder << type << "." << GetProtocolString(protocol);
return typeBuilder.str();
}
} // namespace
namespace chip {
namespace Dnssd {
MdnsAvahi MdnsAvahi::sInstance;
Poller::Poller()
{
mAvahiPoller.userdata = this;
mAvahiPoller.watch_new = WatchNew;
mAvahiPoller.watch_update = WatchUpdate;
mAvahiPoller.watch_get_events = WatchGetEvents;
mAvahiPoller.watch_free = WatchFree;
mAvahiPoller.timeout_new = TimeoutNew;
mAvahiPoller.timeout_update = TimeoutUpdate;
mAvahiPoller.timeout_free = TimeoutFree;
mEarliestTimeout = std::chrono::steady_clock::time_point();
}
AvahiWatch * Poller::WatchNew(const struct AvahiPoll * poller, int fd, AvahiWatchEvent event, AvahiWatchCallback callback,
void * context)
{
return reinterpret_cast<Poller *>(poller->userdata)->WatchNew(fd, event, callback, context);
}
AvahiWatch * Poller::WatchNew(int fd, AvahiWatchEvent event, AvahiWatchCallback callback, void * context)
{
VerifyOrDie(callback != nullptr && fd >= 0);
auto watch = std::make_unique<AvahiWatch>();
watch->mSocket = fd;
LogErrorOnFailure(DeviceLayer::SystemLayerSockets().StartWatchingSocket(fd, &watch->mSocketWatch));
LogErrorOnFailure(DeviceLayer::SystemLayerSockets().SetCallback(watch->mSocketWatch, AvahiWatchCallbackTrampoline,
reinterpret_cast<intptr_t>(watch.get())));
WatchUpdate(watch.get(), event);
watch->mCallback = callback;
watch->mContext = context;
watch->mPoller = this;
mWatches.emplace_back(std::move(watch));
return mWatches.back().get();
}
void Poller::WatchUpdate(AvahiWatch * watch, AvahiWatchEvent event)
{
if (event & AVAHI_WATCH_IN)
{
LogErrorOnFailure(DeviceLayer::SystemLayerSockets().RequestCallbackOnPendingRead(watch->mSocketWatch));
}
else
{
LogErrorOnFailure(DeviceLayer::SystemLayerSockets().ClearCallbackOnPendingRead(watch->mSocketWatch));
}
if (event & AVAHI_WATCH_OUT)
{
LogErrorOnFailure(DeviceLayer::SystemLayerSockets().RequestCallbackOnPendingWrite(watch->mSocketWatch));
}
else
{
LogErrorOnFailure(DeviceLayer::SystemLayerSockets().ClearCallbackOnPendingWrite(watch->mSocketWatch));
}
}
AvahiWatchEvent Poller::WatchGetEvents(AvahiWatch * watch)
{
return watch->mPendingIO;
}
void Poller::WatchFree(AvahiWatch * watch)
{
reinterpret_cast<Poller *>(watch->mPoller)->WatchFree(*watch);
}
void Poller::WatchFree(AvahiWatch & watch)
{
DeviceLayer::SystemLayerSockets().StopWatchingSocket(&watch.mSocketWatch);
mWatches.erase(std::remove_if(mWatches.begin(), mWatches.end(),
[&watch](const std::unique_ptr<AvahiWatch> & aValue) { return aValue.get() == &watch; }),
mWatches.end());
}
AvahiTimeout * Poller::TimeoutNew(const AvahiPoll * poller, const struct timeval * timeout, AvahiTimeoutCallback callback,
void * context)
{
VerifyOrDie(poller != nullptr && callback != nullptr);
return static_cast<Poller *>(poller->userdata)->TimeoutNew(timeout, callback, context);
}
steady_clock::time_point GetAbsTimeout(const struct timeval * timeout)
{
steady_clock::time_point now = steady_clock::now();
steady_clock::time_point absTimeout = now;
if (timeout != nullptr)
{
absTimeout += seconds(timeout->tv_sec);
absTimeout += microseconds(timeout->tv_usec);
}
return absTimeout;
}
AvahiTimeout * Poller::TimeoutNew(const struct timeval * timeout, AvahiTimeoutCallback callback, void * context)
{
mTimers.emplace_back(new AvahiTimeout{ GetAbsTimeout(timeout), callback, timeout != nullptr, context, this });
AvahiTimeout * timer = mTimers.back().get();
SystemTimerUpdate(timer);
return timer;
}
void Poller::TimeoutUpdate(AvahiTimeout * timer, const struct timeval * timeout)
{
if (timeout)
{
timer->mAbsTimeout = GetAbsTimeout(timeout);
timer->mEnabled = true;
static_cast<Poller *>(timer->mPoller)->SystemTimerUpdate(timer);
}
else
{
timer->mEnabled = false;
}
}
void Poller::TimeoutFree(AvahiTimeout * timer)
{
static_cast<Poller *>(timer->mPoller)->TimeoutFree(*timer);
}
void Poller::TimeoutFree(AvahiTimeout & timer)
{
mTimers.erase(std::remove_if(mTimers.begin(), mTimers.end(),
[&timer](const std::unique_ptr<AvahiTimeout> & aValue) { return aValue.get() == &timer; }),
mTimers.end());
}
void Poller::SystemTimerCallback(System::Layer * layer, void * data)
{
static_cast<Poller *>(data)->HandleTimeout();
}
void Poller::HandleTimeout()
{
mEarliestTimeout = std::chrono::steady_clock::time_point();
steady_clock::time_point now = steady_clock::now();
AvahiTimeout * earliest = nullptr;
for (auto && timer : mTimers)
{
if (!timer->mEnabled)
{
continue;
}
if (timer->mAbsTimeout <= now)
{
timer->mCallback(timer.get(), timer->mContext);
}
else
{
if ((earliest == nullptr) || (timer->mAbsTimeout < earliest->mAbsTimeout))
{
earliest = timer.get();
}
}
}
if (earliest)
{
SystemTimerUpdate(earliest);
}
}
void Poller::SystemTimerUpdate(AvahiTimeout * timer)
{
if ((mEarliestTimeout == std::chrono::steady_clock::time_point()) || (timer->mAbsTimeout < mEarliestTimeout))
{
mEarliestTimeout = timer->mAbsTimeout;
auto delay = std::chrono::duration_cast<chip::System::Clock::Milliseconds32>(steady_clock::now() - mEarliestTimeout);
DeviceLayer::SystemLayer().StartTimer(delay, SystemTimerCallback, this);
}
}
CHIP_ERROR MdnsAvahi::Init(DnssdAsyncReturnCallback initCallback, DnssdAsyncReturnCallback errorCallback, void * context)
{
CHIP_ERROR error = CHIP_NO_ERROR;
int avahiError = 0;
Shutdown();
VerifyOrExit(initCallback != nullptr, error = CHIP_ERROR_INVALID_ARGUMENT);
VerifyOrExit(errorCallback != nullptr, error = CHIP_ERROR_INVALID_ARGUMENT);
VerifyOrExit(mClient == nullptr && mPublishedGroups.empty(), error = CHIP_ERROR_INCORRECT_STATE);
mInitCallback = initCallback;
mErrorCallback = errorCallback;
mAsyncReturnContext = context;
mClient = avahi_client_new(mPoller.GetAvahiPoll(), AVAHI_CLIENT_NO_FAIL, HandleClientState, this, &avahiError);
VerifyOrExit(mClient != nullptr, error = CHIP_ERROR_OPEN_FAILED);
VerifyOrExit(avahiError == 0, error = CHIP_ERROR_OPEN_FAILED);
exit:
return error;
}
void MdnsAvahi::Shutdown()
{
StopPublish();
if (mClient)
{
avahi_client_free(mClient);
mClient = nullptr;
}
}
CHIP_ERROR MdnsAvahi::SetHostname(const char * hostname)
{
CHIP_ERROR error = CHIP_NO_ERROR;
VerifyOrExit(mClient != nullptr, error = CHIP_ERROR_INCORRECT_STATE);
// Note: we do no longer set the primary hostname here, as other services
// on the platform might not be happy with the matter mandated hostname.
// Instead, we'll establish our own hostname when needed (see PublishService())
exit:
return error;
}
void MdnsAvahi::HandleClientState(AvahiClient * client, AvahiClientState state, void * context)
{
static_cast<MdnsAvahi *>(context)->HandleClientState(client, state);
}
void MdnsAvahi::HandleClientState(AvahiClient * client, AvahiClientState state)
{
switch (state)
{
case AVAHI_CLIENT_S_RUNNING:
ChipLogProgress(DeviceLayer, "Avahi client registered");
mClient = client;
// no longer create groups here, but on a by-service basis in PublishService()
mInitCallback(mAsyncReturnContext, CHIP_NO_ERROR);
break;
case AVAHI_CLIENT_FAILURE:
ChipLogError(DeviceLayer, "Avahi client failure");
mErrorCallback(mAsyncReturnContext, CHIP_ERROR_INTERNAL);
break;
case AVAHI_CLIENT_S_COLLISION:
case AVAHI_CLIENT_S_REGISTERING:
ChipLogProgress(DeviceLayer, "Avahi re-register required");
StopPublish();
mErrorCallback(mAsyncReturnContext, CHIP_ERROR_FORCED_RESET);
break;
case AVAHI_CLIENT_CONNECTING:
ChipLogProgress(DeviceLayer, "Avahi connecting");
break;
}
}
void MdnsAvahi::HandleGroupState(AvahiEntryGroup * group, AvahiEntryGroupState state, void * context)
{
static_cast<MdnsAvahi *>(context)->HandleGroupState(group, state);
}
void MdnsAvahi::HandleGroupState(AvahiEntryGroup * group, AvahiEntryGroupState state)
{
switch (state)
{
case AVAHI_ENTRY_GROUP_ESTABLISHED:
ChipLogProgress(DeviceLayer, "Avahi group established");
break;
case AVAHI_ENTRY_GROUP_COLLISION:
ChipLogError(DeviceLayer, "Avahi group collision");
mErrorCallback(mAsyncReturnContext, CHIP_ERROR_MDNS_COLLISION);
break;
case AVAHI_ENTRY_GROUP_FAILURE:
ChipLogError(DeviceLayer, "Avahi group internal failure %s",
avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(group))));
mErrorCallback(mAsyncReturnContext, CHIP_ERROR_INTERNAL);
break;
case AVAHI_ENTRY_GROUP_UNCOMMITED:
case AVAHI_ENTRY_GROUP_REGISTERING:
break;
}
}
CHIP_ERROR MdnsAvahi::PublishService(const DnssdService & service, DnssdPublishCallback callback, void * context)
{
std::ostringstream keyBuilder;
std::string key;
std::string type = GetFullType(service.mType, service.mProtocol);
std::string matterHostname;
CHIP_ERROR error = CHIP_NO_ERROR;
AvahiStringList * text = nullptr;
AvahiEntryGroup * group = nullptr;
const char * mainHostname = nullptr;
AvahiIfIndex interface =
service.mInterface.IsPresent() ? static_cast<AvahiIfIndex>(service.mInterface.GetPlatformInterface()) : AVAHI_IF_UNSPEC;
AvahiProtocol protocol = ToAvahiProtocol(service.mAddressType);
keyBuilder << service.mName << "." << type << service.mPort << "." << interface;
key = keyBuilder.str();
ChipLogProgress(DeviceLayer, "PublishService %s", key.c_str());
auto publishedgroups_it = mPublishedGroups.find(key);
if (publishedgroups_it != mPublishedGroups.end())
{
// same service was already published, we need to de-publish it first
int avahiRet = avahi_entry_group_free(publishedgroups_it->second);
if (avahiRet != AVAHI_OK)
{
ChipLogError(DeviceLayer, "Cannot remove avahi group: %s", avahi_strerror(avahiRet));
ExitNow(error = CHIP_ERROR_INTERNAL);
}
mPublishedGroups.erase(publishedgroups_it);
}
// create fresh group
group = avahi_entry_group_new(mClient, HandleGroupState, this);
VerifyOrExit(group != nullptr, error = CHIP_ERROR_INTERNAL);
// establish the host name (separately from avahi's default host name that the platform might have,
// unless it matches the matter hostname)
mainHostname = avahi_client_get_host_name(mClient);
if (strcmp(mainHostname, service.mHostName) == 0)
{
// main host name is correct, we can use it
matterHostname = std::string(mainHostname) + ".local";
}
else
{
// we need to establish a matter hostname separately from the platform's default hostname
char b[chip::Inet::IPAddress::kMaxStringLength];
SuccessOrExit(error = service.mInterface.GetInterfaceName(b, chip::Inet::IPAddress::kMaxStringLength));
ChipLogDetail(DeviceLayer, "Using addresses from interface id=%d name=%s", service.mInterface.GetPlatformInterface(), b);
matterHostname = std::string(service.mHostName) + ".local";
// find addresses to publish
for (chip::Inet::InterfaceAddressIterator addr_it; addr_it.HasCurrent(); addr_it.Next())
{
// only specific interface?
if (service.mInterface.IsPresent() && addr_it.GetInterfaceId() != service.mInterface)
{
continue;
}
if (addr_it.IsUp())
{
if (addr_it.IsLoopback())
{
// do not advertise loopback interface addresses
continue;
}
chip::Inet::IPAddress addr;
if ((addr_it.GetAddress(addr) == CHIP_NO_ERROR) &&
((service.mAddressType == chip::Inet::IPAddressType::kAny) ||
(addr.IsIPv6() && service.mAddressType == chip::Inet::IPAddressType::kIPv6)
#if INET_CONFIG_ENABLE_IPV4
|| (addr.IsIPv4() && service.mAddressType == chip::Inet::IPAddressType::kIPv4)
#endif
))
{
VerifyOrExit(addr.ToString(b) != nullptr, error = CHIP_ERROR_INTERNAL);
AvahiAddress a;
VerifyOrExit(avahi_address_parse(b, AVAHI_PROTO_UNSPEC, &a) != nullptr, error = CHIP_ERROR_INTERNAL);
AvahiIfIndex thisinterface = static_cast<AvahiIfIndex>(addr_it.GetInterfaceId().GetPlatformInterface());
// Note: NO_REVERSE publish flag is needed because otherwise we can't have more than one hostname
// for reverse resolving IP addresses back to hostnames
VerifyOrExit(avahi_entry_group_add_address(group, // group
thisinterface, // interface
ToAvahiProtocol(addr.Type()), // protocol
AVAHI_PUBLISH_NO_REVERSE, // publish flags
matterHostname.c_str(), // hostname
&a // address
) == 0,
error = CHIP_ERROR_INTERNAL);
}
}
}
}
// create the service
SuccessOrExit(error = MakeAvahiStringListFromTextEntries(service.mTextEntries, service.mTextEntrySize, &text));
VerifyOrExit(avahi_entry_group_add_service_strlst(group, interface, protocol, // group, interface, protocol
static_cast<AvahiPublishFlags>(0), // publish flags
service.mName, // service name
type.c_str(), // type
nullptr, // domain
matterHostname.c_str(), // host
service.mPort, // port
text) == 0, // TXT records StringList
error = CHIP_ERROR_INTERNAL);
// add the subtypes
for (size_t i = 0; i < service.mSubTypeSize; i++)
{
std::ostringstream sstream;
sstream << service.mSubTypes[i] << "._sub." << type;
VerifyOrExit(avahi_entry_group_add_service_subtype(group, interface, protocol, static_cast<AvahiPublishFlags>(0),
service.mName, type.c_str(), nullptr, sstream.str().c_str()) == 0,
error = CHIP_ERROR_INTERNAL);
}
VerifyOrExit(avahi_entry_group_commit(group) == 0, error = CHIP_ERROR_INTERNAL);
// group is now published, pass it to the service map
mPublishedGroups[key] = group;
group = nullptr;
exit:
if (group != nullptr)
{
avahi_entry_group_free(group);
}
if (text != nullptr)
{
avahi_string_list_free(text);
}
// Ideally the callback would be called from `HandleGroupState` when the `AVAHI_ENTRY_GROUP_ESTABLISHED` state
// is received. But the current code use the `userdata` field to pass a pointer to the current MdnsAvahi instance
// and this is all comes from MdnsAvahi::Init that does not have any clue about the `type` that *will* be published.
// The code needs to be updated to support that callback properly.
if (CHIP_NO_ERROR == error)
{
callback(context, type.c_str(), service.mName, CHIP_NO_ERROR);
}
else
{
ChipLogError(DeviceLayer, "PublishService failed: %s",
mClient ? avahi_strerror(avahi_client_errno(mClient)) : "no mClient");
callback(context, nullptr, nullptr, error);
}
return error;
}
CHIP_ERROR MdnsAvahi::StopPublish()
{
CHIP_ERROR error = CHIP_NO_ERROR;
for (const auto & group : mPublishedGroups)
{
if (group.second)
{
int avahiRet = avahi_entry_group_free(group.second);
if (avahiRet != AVAHI_OK)
{
ChipLogError(DeviceLayer, "Error freeing avahi group: %s", avahi_strerror(avahiRet));
error = CHIP_ERROR_INTERNAL;
}
}
}
mPublishedGroups.clear();
return error;
}
CHIP_ERROR MdnsAvahi::Browse(const char * type, DnssdServiceProtocol protocol, chip::Inet::IPAddressType addressType,
chip::Inet::InterfaceId interface, DnssdBrowseCallback callback, void * context,
intptr_t * browseIdentifier)
{
AvahiServiceBrowser * browser;
BrowseContext * browseContext = chip::Platform::New<BrowseContext>();
AvahiIfIndex avahiInterface = static_cast<AvahiIfIndex>(interface.GetPlatformInterface());
browseContext->mInstance = this;
browseContext->mContext = context;
browseContext->mCallback = callback;
browseContext->mAddressType = addressType;
if (!interface.IsPresent())
{
avahiInterface = AVAHI_IF_UNSPEC;
}
browseContext->mInterface = avahiInterface;
browseContext->mProtocol = GetFullType(type, protocol);
browseContext->mBrowseRetries = 0;
browseContext->mStopped.store(false);
browser = avahi_service_browser_new(mClient, avahiInterface, AVAHI_PROTO_UNSPEC, browseContext->mProtocol.c_str(), nullptr,
static_cast<AvahiLookupFlags>(0), HandleBrowse, browseContext);
// Otherwise the browser will be freed in the callback
if (browser == nullptr)
{
chip::Platform::Delete(browseContext);
*browseIdentifier = reinterpret_cast<intptr_t>(nullptr);
}
else
{
*browseIdentifier = reinterpret_cast<intptr_t>(browseContext);
}
return browser == nullptr ? CHIP_ERROR_INTERNAL : CHIP_NO_ERROR;
}
CHIP_ERROR MdnsAvahi::StopBrowse(intptr_t browseIdentifier)
{
BrowseContext * browseContext = reinterpret_cast<BrowseContext *>(browseIdentifier);
if (browseContext == nullptr)
{
return CHIP_ERROR_NOT_FOUND;
}
// Any running timers here will check mStopped before rescheduling. Leave the timer running
// so we don't race on deletion of the browse context.
browseContext->mStopped.store(true);
return CHIP_NO_ERROR;
}
DnssdServiceProtocol GetProtocolInType(const char * type)
{
const char * deliminator = strrchr(type, '.');
if (deliminator == nullptr)
{
ChipLogError(Discovery, "Failed to find protocol in type: %s", StringOrNullMarker(type));
return DnssdServiceProtocol::kDnssdProtocolUnknown;
}
if (strcmp("._tcp", deliminator) == 0)
{
return DnssdServiceProtocol::kDnssdProtocolTcp;
}
if (strcmp("._udp", deliminator) == 0)
{
return DnssdServiceProtocol::kDnssdProtocolUdp;
}
ChipLogError(Discovery, "Unknown protocol in type: %s", StringOrNullMarker(type));
return DnssdServiceProtocol::kDnssdProtocolUnknown;
}
/// Copies the type from a string containing both type and protocol
///
/// e.g. if input is "foo.bar", output is "foo", input is 'a.b._tcp", output is "a.b"
template <size_t N>
void CopyTypeWithoutProtocol(char (&dest)[N], const char * typeAndProtocol)
{
const char * dotPos = strrchr(typeAndProtocol, '.');
size_t lengthWithoutProtocol = (dotPos != nullptr) ? static_cast<size_t>(dotPos - typeAndProtocol) : N;
Platform::CopyString(dest, typeAndProtocol);
/// above copied everything including the protocol. Truncate the protocol away.
if (lengthWithoutProtocol < N)
{
dest[lengthWithoutProtocol] = 0;
}
}
void MdnsAvahi::BrowseRetryCallback(chip::System::Layer * aLayer, void * appState)
{
BrowseContext * context = static_cast<BrowseContext *>(appState);
// Don't schedule anything new if we've stopped.
if (context->mStopped.load())
{
chip::Platform::Delete(context);
return;
}
AvahiServiceBrowser * newBrowser =
avahi_service_browser_new(context->mInstance->mClient, context->mInterface, AVAHI_PROTO_UNSPEC, context->mProtocol.c_str(),
nullptr, static_cast<AvahiLookupFlags>(0), HandleBrowse, context);
if (newBrowser == nullptr)
{
// If we failed to create the browser, this browse context is effectively done. We need to call the final callback and
// delete the context.
context->mCallback(context->mContext, context->mServices.data(), context->mServices.size(), true, CHIP_NO_ERROR);
chip::Platform::Delete(context);
}
}
void MdnsAvahi::HandleBrowse(AvahiServiceBrowser * browser, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event,
const char * name, const char * type, const char * domain, AvahiLookupResultFlags /*flags*/,
void * userdata)
{
BrowseContext * context = static_cast<BrowseContext *>(userdata);
switch (event)
{
case AVAHI_BROWSER_FAILURE:
context->mCallback(context->mContext, nullptr, 0, true, CHIP_ERROR_INTERNAL);
avahi_service_browser_free(browser);
chip::Platform::Delete(context);
break;
case AVAHI_BROWSER_NEW:
ChipLogProgress(DeviceLayer, "Avahi browse: cache new");
if (strcmp("local", domain) == 0)
{
DnssdService service = {};
Platform::CopyString(service.mName, name);
CopyTypeWithoutProtocol(service.mType, type);
service.mProtocol = GetProtocolInType(type);
service.mAddressType = context->mAddressType;
service.mTransportType = ToAddressType(protocol);
service.mInterface = Inet::InterfaceId::Null();
if (interface != AVAHI_IF_UNSPEC)
{
service.mInterface = static_cast<chip::Inet::InterfaceId>(interface);
}
service.mType[kDnssdTypeMaxSize] = 0;
context->mServices.push_back(service);
}
break;
case AVAHI_BROWSER_ALL_FOR_NOW: {
ChipLogProgress(DeviceLayer, "Avahi browse: all for now");
bool needRetries = context->mBrowseRetries++ < kMaxBrowseRetries && !context->mStopped.load();
// If we were already asked to stop, no need to send a callback - no one is listening.
if (!context->mStopped.load())
{
context->mCallback(context->mContext, context->mServices.data(), context->mServices.size(), !needRetries,
CHIP_NO_ERROR);
}
avahi_service_browser_free(browser);
if (needRetries)
{
context->mNextRetryDelay *= 2;
// Hand the ownership of the context over to the timer. It will either schedule a new browse on the context,
// triggering this function, or it will delete and not reschedule (if stopped).
DeviceLayer::SystemLayer().StartTimer(context->mNextRetryDelay / 2, BrowseRetryCallback, context);
}
else
{
// We didn't schedule a timer, so we're responsible for deleting the context
chip::Platform::Delete(context);
}
break;
}
case AVAHI_BROWSER_REMOVE:
ChipLogProgress(DeviceLayer, "Avahi browse: remove");
if (strcmp("local", domain) == 0)
{
context->mServices.erase(
std::remove_if(context->mServices.begin(), context->mServices.end(), [name, type](const DnssdService & service) {
return strcmp(name, service.mName) == 0 && type == GetFullType(service.mType, service.mProtocol);
}));
}
break;
case AVAHI_BROWSER_CACHE_EXHAUSTED:
ChipLogProgress(DeviceLayer, "Avahi browse: cache exhausted");
break;
}
}
MdnsAvahi::ResolveContext * MdnsAvahi::AllocateResolveContext()
{
ResolveContext * context = chip::Platform::New<ResolveContext>();
if (context == nullptr)
{
return nullptr;
}
context->mNumber = mResolveCount++;
mAllocatedResolves.push_back(context);
return context;
}
MdnsAvahi::ResolveContext * MdnsAvahi::ResolveContextForHandle(size_t handle)
{
for (auto it : mAllocatedResolves)
{
if (it->mNumber == handle)
{
return it;
}
}
return nullptr;
}
void MdnsAvahi::FreeResolveContext(size_t handle)
{
for (auto it = mAllocatedResolves.begin(); it != mAllocatedResolves.end(); it++)
{
if ((*it)->mNumber == handle)
{
chip::Platform::Delete(*it);
mAllocatedResolves.erase(it);
return;
}
}
}
void MdnsAvahi::StopResolve(const char * name)
{
auto truncate_end = std::remove_if(mAllocatedResolves.begin(), mAllocatedResolves.end(),
[name](ResolveContext * ctx) { return strcmp(ctx->mName, name) == 0; });
for (auto it = truncate_end; it != mAllocatedResolves.end(); it++)
{
(*it)->mCallback((*it)->mContext, nullptr, Span<Inet::IPAddress>(), CHIP_ERROR_CANCELLED);
chip::Platform::Delete(*it);
}
mAllocatedResolves.erase(truncate_end, mAllocatedResolves.end());
}
CHIP_ERROR MdnsAvahi::Resolve(const char * name, const char * type, DnssdServiceProtocol protocol, Inet::IPAddressType addressType,
Inet::IPAddressType transportType, Inet::InterfaceId interface, DnssdResolveCallback callback,
void * context)
{
AvahiIfIndex avahiInterface = static_cast<AvahiIfIndex>(interface.GetPlatformInterface());
ResolveContext * resolveContext = AllocateResolveContext();
CHIP_ERROR error = CHIP_NO_ERROR;
resolveContext->mInstance = this;
resolveContext->mCallback = callback;
resolveContext->mContext = context;
if (!interface.IsPresent())
{
avahiInterface = AVAHI_IF_UNSPEC;
}
Platform::CopyString(resolveContext->mName, name);
resolveContext->mInterface = avahiInterface;
resolveContext->mTransport = ToAvahiProtocol(transportType);
resolveContext->mAddressType = ToAvahiProtocol(addressType);
resolveContext->mFullType = GetFullType(type, protocol);
AvahiServiceResolver * resolver =
avahi_service_resolver_new(mClient, avahiInterface, resolveContext->mTransport, name, resolveContext->mFullType.c_str(),
nullptr, resolveContext->mAddressType, static_cast<AvahiLookupFlags>(0), HandleResolve,
reinterpret_cast<void *>(resolveContext->mNumber));
// Otherwise the resolver will be freed in the callback
if (resolver == nullptr)
{
error = CHIP_ERROR_INTERNAL;
chip::Platform::Delete(resolveContext);
}
resolveContext->mResolver = resolver;
return error;
}
void MdnsAvahi::HandleResolve(AvahiServiceResolver * resolver, AvahiIfIndex interface, AvahiProtocol protocol,
AvahiResolverEvent event, const char * name, const char * type, const char * /*domain*/,
const char * host_name, const AvahiAddress * address, uint16_t port, AvahiStringList * txt,
AvahiLookupResultFlags flags, void * userdata)
{
size_t handle = reinterpret_cast<size_t>(userdata);
ResolveContext * context = sInstance.ResolveContextForHandle(handle);
std::vector<TextEntry> textEntries;
if (context == nullptr)
{
ChipLogError(Discovery, "Invalid context for handling resolves: %ld", static_cast<long>(handle));
return;
}
switch (event)
{
case AVAHI_RESOLVER_FAILURE:
if (context->mAttempts++ < 3)
{
ChipLogProgress(DeviceLayer, "Re-trying resolve");
avahi_service_resolver_free(resolver);
context->mResolver = avahi_service_resolver_new(
context->mInstance->mClient, context->mInterface, context->mTransport, context->mName, context->mFullType.c_str(),
nullptr, context->mAddressType, static_cast<AvahiLookupFlags>(0), HandleResolve, userdata);
if (context->mResolver == nullptr)
{
ChipLogError(DeviceLayer, "Avahi resolve failed on retry");
context->mCallback(context->mContext, nullptr, Span<Inet::IPAddress>(), CHIP_ERROR_INTERNAL);
sInstance.FreeResolveContext(handle);
}
return;
}
ChipLogError(DeviceLayer, "Avahi resolve failed");
context->mCallback(context->mContext, nullptr, Span<Inet::IPAddress>(), CHIP_ERROR_INTERNAL);
break;
case AVAHI_RESOLVER_FOUND:
DnssdService result = {};
ChipLogProgress(DeviceLayer, "Avahi resolve found");
Platform::CopyString(result.mName, name);
CopyTypeWithoutProtocol(result.mType, type);
result.mProtocol = GetProtocolInType(type);
result.mPort = port;
result.mAddressType = ToAddressType(protocol);
result.mInterface = Inet::InterfaceId::Null();
// It's not clear if we can get the actual value from avahi, so just assume default.
result.mTtlSeconds = AVAHI_DEFAULT_TTL_HOST_NAME;
if (interface != AVAHI_IF_UNSPEC)
{
result.mInterface = static_cast<chip::Inet::InterfaceId>(interface);
}
Platform::CopyString(result.mHostName, host_name);
// Returned value is full QName, want only host part.
char * dot = strchr(result.mHostName, '.');
if (dot != nullptr)
{
*dot = '\0';
}
CHIP_ERROR result_err = CHIP_ERROR_INVALID_ADDRESS;
chip::Inet::IPAddress ipAddress; // Will be set of result_err is set to CHIP_NO_ERROR
if (address)
{
switch (address->proto)
{
case AVAHI_PROTO_INET:
#if INET_CONFIG_ENABLE_IPV4
struct in_addr addr4;
memcpy(&addr4, &(address->data.ipv4), sizeof(addr4));
ipAddress = chip::Inet::IPAddress(addr4);
result_err = CHIP_NO_ERROR;
#else
ChipLogError(Discovery, "Ignoring IPv4 mDNS address.");
#endif
break;
case AVAHI_PROTO_INET6:
struct in6_addr addr6;
memcpy(&addr6, &(address->data.ipv6), sizeof(addr6));
ipAddress = chip::Inet::IPAddress(addr6);
result_err = CHIP_NO_ERROR;
break;
default:
break;
}
}
while (txt != nullptr)
{
for (size_t i = 0; i < txt->size; i++)
{
if (txt->text[i] == '=')
{
txt->text[i] = '\0';
textEntries.push_back(TextEntry{ reinterpret_cast<char *>(txt->text), &txt->text[i + 1], txt->size - i - 1 });
break;
}
}
txt = txt->next;
}
if (!textEntries.empty())
{
result.mTextEntries = textEntries.data();
}
result.mTextEntrySize = textEntries.size();
if (result_err == CHIP_NO_ERROR)
{
context->mCallback(context->mContext, &result, Span<Inet::IPAddress>(&ipAddress, 1), CHIP_NO_ERROR);
}
else
{
context->mCallback(context->mContext, nullptr, Span<Inet::IPAddress>(), result_err);
}
break;
}
sInstance.FreeResolveContext(handle);
}
CHIP_ERROR ChipDnssdInit(DnssdAsyncReturnCallback initCallback, DnssdAsyncReturnCallback errorCallback, void * context)
{
return MdnsAvahi::GetInstance().Init(initCallback, errorCallback, context);
}
void ChipDnssdShutdown()
{
MdnsAvahi::GetInstance().Shutdown();
}
CHIP_ERROR ChipDnssdPublishService(const DnssdService * service, DnssdPublishCallback callback, void * context)
{
VerifyOrReturnError(service != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
VerifyOrReturnError(callback != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
if (strcmp(service->mHostName, "") != 0)
{
ReturnErrorOnFailure(MdnsAvahi::GetInstance().SetHostname(service->mHostName));
}
return MdnsAvahi::GetInstance().PublishService(*service, callback, context);
}
CHIP_ERROR ChipDnssdRemoveServices()
{
return MdnsAvahi::GetInstance().StopPublish();
}
CHIP_ERROR ChipDnssdFinalizeServiceUpdate()
{
return CHIP_NO_ERROR;
}
CHIP_ERROR ChipDnssdBrowse(const char * type, DnssdServiceProtocol protocol, chip::Inet::IPAddressType addressType,
chip::Inet::InterfaceId interface, DnssdBrowseCallback callback, void * context,
intptr_t * browseIdentifier)
{
return MdnsAvahi::GetInstance().Browse(type, protocol, addressType, interface, callback, context, browseIdentifier);
}
CHIP_ERROR ChipDnssdStopBrowse(intptr_t browseIdentifier)
{
return MdnsAvahi::GetInstance().StopBrowse(browseIdentifier);
}
CHIP_ERROR ChipDnssdResolve(DnssdService * browseResult, chip::Inet::InterfaceId interface, DnssdResolveCallback callback,
void * context)
{
VerifyOrReturnError(browseResult != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
return MdnsAvahi::GetInstance().Resolve(browseResult->mName, browseResult->mType, browseResult->mProtocol,
browseResult->mAddressType, Inet::IPAddressType::kAny, interface, callback, context);
}
void ChipDnssdResolveNoLongerNeeded(const char * instanceName)
{
MdnsAvahi::GetInstance().StopResolve(instanceName);
}
CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
{
return CHIP_ERROR_NOT_IMPLEMENTED;
}
} // namespace Dnssd
} // namespace chip