+++ /dev/null
-# Copyright (c) 2020 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.
-
-import("//build_overrides/chip.gni")
-import("//build_overrides/mbedtls.gni")
-import("//build_overrides/nlassert.gni")
-import("//build_overrides/nlio.gni")
-import("//build_overrides/nlunit_test.gni")
-import("//build_overrides/pigweed.gni")
-
-# This build file should not be used in superproject builds.
-assert(chip_root == "//")
-
-import("${chip_root}/build/chip/tests.gni")
-import("${chip_root}/build/chip/tools.gni")
-
-if (current_toolchain != "${dir_pw_toolchain}/dummy:dummy") {
- declare_args() {
- chip_enable_python_modules =
- (current_os == "mac" || current_os == "linux") && host_cpu == "x64"
- }
-
- # This is a real toolchain. Build CHIP.
- group("default") {
- deps = [ ":all" ]
- }
-
- group("all") {
- deps = [
- "${chip_root}/src/app",
- "${chip_root}/src/ble",
- "${chip_root}/src/controller",
- "${chip_root}/src/crypto",
- "${chip_root}/src/inet",
- "${chip_root}/src/lib",
- "${chip_root}/src/lib/asn1",
- "${chip_root}/src/lib/core",
- "${chip_root}/src/lib/shell",
- "${chip_root}/src/lib/support",
- "${chip_root}/src/lwip:all",
- "${chip_root}/src/messaging",
- "${chip_root}/src/protocols",
- "${chip_root}/src/setup_payload",
- "${chip_root}/src/system",
- "${chip_root}/src/transport",
- "${mbedtls_root}:mbedtls",
- "${nlassert_root}:nlassert",
- "${nlio_root}:nlio",
- "${nlunit_test_root}:nlunit-test",
- ]
-
- if (chip_build_tests) {
- deps += [ "//src:tests" ]
- }
-
- if (chip_build_tools) {
- deps += [
- "${chip_root}/examples/shell/standalone:chip-shell",
- "${chip_root}/src/qrcodetool",
- "${chip_root}/src/setup_payload",
- ]
- if (chip_enable_python_modules) {
- deps += [ "${chip_root}/src/controller/python" ]
- }
- }
-
- if (current_os == "android") {
- deps += [
- "${chip_root}/src/controller/java",
- "${chip_root}/src/setup_payload/java",
- ]
- }
-
- deps += [
- "${chip_root}/examples/all-clusters-app/linux",
- "${chip_root}/examples/lighting-app/linux",
- "${chip_root}/examples/chip-tool",
- "${chip_root}/examples/minimal-mdns:minimal-mdns-client",
- "${chip_root}/examples/minimal-mdns:minimal-mdns-server",
- ]
- }
-
- group("check") {
- if (chip_link_tests) {
- deps = [ "//src:tests_run" ]
- }
- }
-
- # We don't always want to run happy tests, make them a seperate group.
- if (chip_enable_happy_tests) {
- group("happy_tests") {
- if (chip_link_tests) {
- deps = [ "//src:happy_tests" ]
- }
- }
- }
-} else {
- # This is the unified build. Configure various real toolchains.
- import("${chip_root}/build/chip/chip_build.gni")
- declare_args() {
- # Set this to false to disable all builds by default.
- enable_default_builds = true
-
- # Enable building for Android.
- enable_android_builds = false
-
- # Set this to true to enable efr32 builds by default.
- enable_efr32_builds = false
-
- # Set this to true to enable qpg6100 builds by default.
- enable_qpg6100_builds = false
-
- # Set this to true to enable k32w builds by default.
- enable_k32w_builds = false
- }
-
- declare_args() {
- # Enable building chip with clang.
- enable_host_clang_build = enable_default_builds
-
- # Enable building chip with gcc.
- enable_host_gcc_build = enable_default_builds
-
- # Enable building chip with gcc & mbedtls.
- enable_host_gcc_mbedtls_build = enable_default_builds
-
- # Build the chip-tool example.
- enable_standalone_chip_tool_build = enable_default_builds
-
- # Build the shell example.
- enable_standalone_shell_build = enable_default_builds
-
- # Build the Linux all clusters app example.
- enable_linux_all_clusters_app_build =
- enable_default_builds && host_os == "linux"
-
- # Build the Linux lighting app example.
- enable_linux_lighting_app_build =
- enable_default_builds && host_os == "linux"
-
- # Build the efr32 lock app example.
- enable_efr32_lock_app_build = enable_efr32_builds
-
- # Build the qpg6100 lock app example.
- enable_qpg6100_lock_app_build = enable_qpg6100_builds
-
- # Build the efr32 lighting app example.
- enable_efr32_lighting_app_build = enable_efr32_builds
-
- # Build the k32w lock app example.
- enable_k32w_lock_app_build = enable_k32w_builds
- }
-
- if (enable_host_clang_build) {
- chip_build("host_clang") {
- toolchain = "//build/toolchain/host:${host_os}_${host_cpu}_clang"
- }
- }
-
- if (enable_host_gcc_build) {
- chip_build("host_gcc") {
- toolchain = "//build/toolchain/host:${host_os}_${host_cpu}_gcc"
- }
- }
-
- if (enable_host_gcc_mbedtls_build) {
- chip_build("host_gcc_mbedtls") {
- toolchain = "${chip_root}/config/mbedtls/toolchain:${host_os}_${host_cpu}_gcc_mbedtls"
- }
- }
-
- if (enable_android_builds) {
- chip_build("android_arm") {
- toolchain = "//build/toolchain/android:android_arm"
- }
-
- chip_build("android_arm64") {
- toolchain = "//build/toolchain/android:android_arm64"
- }
-
- chip_build("android_x64") {
- toolchain = "//build/toolchain/android:android_x64"
- }
-
- chip_build("android_x86") {
- toolchain = "//build/toolchain/android:android_x86"
- }
- }
-
- standalone_toolchain = "${chip_root}/config/standalone/toolchain:standalone"
-
- if (enable_standalone_chip_tool_build) {
- group("standalone_chip_tool") {
- deps = [ "${chip_root}/examples/chip-tool(${standalone_toolchain})" ]
- }
- }
-
- if (enable_standalone_shell_build) {
- group("standalone_shell") {
- deps =
- [ "${chip_root}/examples/shell/standalone(${standalone_toolchain})" ]
- }
- }
-
- if (enable_linux_all_clusters_app_build) {
- group("linux_all_clusters_app") {
- deps = [
- "${chip_root}/examples/all-clusters-app/linux(${standalone_toolchain})",
- ]
- }
- }
-
- if (enable_linux_lighting_app_build) {
- group("linux_lighting_app") {
- deps = [
- "${chip_root}/examples/lighting-app/linux(${standalone_toolchain})",
- ]
- }
- }
-
- if (enable_efr32_lock_app_build) {
- group("efr32_lock_app") {
- deps = [ "${chip_root}/examples/lock-app/efr32(${chip_root}/config/efr32/toolchain:efr32_lock_app)" ]
- }
- }
-
- if (enable_qpg6100_lock_app_build) {
- group("qpg6100_lock_app") {
- deps = [ "${chip_root}/examples/lock-app/qpg6100(${chip_root}/config/qpg6100/toolchain:qpg6100_lock_app)" ]
- }
- }
-
- if (enable_efr32_lighting_app_build) {
- group("efr32_lighting_app") {
- deps = [ "${chip_root}/examples/lighting-app/efr32(${chip_root}/config/efr32/toolchain:efr32_lighting_app)" ]
- }
- }
-
- if (enable_k32w_lock_app_build) {
- group("k32w_lock_app") {
- deps = [ "${chip_root}/examples/lock-app/k32w(${chip_root}/config/k32w/toolchain:k32w_lock_app)" ]
- }
- }
-
- group("default") {
- deps = []
- if (enable_host_clang_build) {
- deps += [ ":all_host_clang" ]
- }
- if (enable_host_gcc_build) {
- deps += [ ":all_host_gcc" ]
- }
- if (enable_host_gcc_mbedtls_build) {
- deps += [ ":all_host_gcc_mbedtls" ]
- }
- if (enable_android_builds) {
- deps += [
- ":all_android_arm",
- ":all_android_arm64",
- ":all_android_x64",
- ":all_android_x86",
- ]
- }
- if (enable_standalone_chip_tool_build) {
- deps += [ ":standalone_chip_tool" ]
- }
- if (enable_standalone_shell_build) {
- deps += [ ":standalone_shell" ]
- }
- if (enable_linux_all_clusters_app_build) {
- deps += [ ":linux_all_clusters_app" ]
- }
- if (enable_linux_lighting_app_build) {
- deps += [ ":linux_lighting_app" ]
- }
- if (enable_efr32_lock_app_build) {
- deps += [ ":efr32_lock_app" ]
- }
- if (enable_k32w_lock_app_build) {
- deps += [ ":k32w_lock_app" ]
- }
- }
-
- group("check") {
- deps = []
- if (enable_host_clang_build) {
- deps += [ ":check_host_clang" ]
- }
- if (enable_host_gcc_build) {
- deps += [ ":check_host_gcc" ]
- }
- if (enable_host_gcc_mbedtls_build) {
- deps += [ ":check_host_gcc_mbedtls" ]
- }
- }
-}
+++ /dev/null
-/*
- *
- * Copyright (c) 2020 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 "MdnsImpl.h"
-
-#include <algorithm>
-#include <sstream>
-#include <string.h>
-#include <time.h>
-#include <vector>
-
-#include <netinet/in.h>
-
-#include "support/CHIPMem.h"
-#include "support/CodeUtils.h"
-
-using chip::Mdns::kMdnsTypeMaxSize;
-using chip::Mdns::MdnsServiceProtocol;
-using chip::Mdns::TextEntry;
-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)
-{
- AvahiProtocol protocol;
-
- switch (addressType)
- {
- case chip::Inet::IPAddressType::kIPAddressType_IPv4:
- protocol = AVAHI_PROTO_INET;
- break;
- case chip::Inet::IPAddressType::kIPAddressType_IPv6:
- protocol = AVAHI_PROTO_INET6;
- break;
- default:
- protocol = AVAHI_PROTO_UNSPEC;
- break;
- }
-
- return protocol;
-}
-
-chip::Inet::IPAddressType ToAddressType(AvahiProtocol protocol)
-{
- chip::Inet::IPAddressType type;
-
- switch (protocol)
- {
- case AVAHI_PROTO_INET:
- type = chip::Inet::IPAddressType::kIPAddressType_IPv4;
- break;
- case AVAHI_PROTO_INET6:
- type = chip::Inet::IPAddressType::kIPAddressType_IPv6;
- break;
- default:
- type = chip::Inet::IPAddressType::kIPAddressType_Unknown;
- break;
- }
-
- return type;
-}
-
-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[kMdnsTypeMaxSize];
- 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(MdnsServiceProtocol protocol)
-{
- return protocol == MdnsServiceProtocol::kMdnsProtocolUdp ? "_udp" : "_tcp";
-}
-
-std::string GetFullType(const char * type, MdnsServiceProtocol protocol)
-{
- std::ostringstream typeBuilder;
- typeBuilder << type << "." << GetProtocolString(protocol);
- return typeBuilder.str();
-}
-
-} // namespace
-
-namespace chip {
-namespace Mdns {
-
-MdnsAvahi MdnsAvahi::sInstance;
-
-constexpr uint64_t kUsPerSec = 1000 * 1000;
-
-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;
-}
-
-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);
-
- mWatches.emplace_back(new AvahiWatch{ fd, event, 0, callback, context, this });
-
- return mWatches.back().get();
-}
-
-void Poller::WatchUpdate(AvahiWatch * watch, AvahiWatchEvent event)
-{
- watch->mWatchEvents = event;
-}
-
-AvahiWatchEvent Poller::WatchGetEvents(AvahiWatch * watch)
-{
- return static_cast<AvahiWatchEvent>(watch->mHappenedEvents);
-}
-
-void Poller::WatchFree(AvahiWatch * watch)
-{
- reinterpret_cast<Poller *>(watch->mPoller)->WatchFree(*watch);
-}
-
-void Poller::WatchFree(AvahiWatch & watch)
-{
- 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 });
- return mTimers.back().get();
-}
-
-void Poller::TimeoutUpdate(AvahiTimeout * timer, const struct timeval * timeout)
-{
- if (timeout)
- {
- timer->mAbsTimeout = GetAbsTimeout(timeout);
- timer->mEnabled = true;
- }
- 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::UpdateFdSet(fd_set & readFdSet, fd_set & writeFdSet, fd_set & errorFdSet, int & aMaxFd, timeval & timeout)
-{
- microseconds timeoutVal = seconds(timeout.tv_sec) + microseconds(timeout.tv_usec);
-
- for (auto && watch : mWatches)
- {
- int fd = watch->mFd;
- AvahiWatchEvent events = watch->mWatchEvents;
-
- if (AVAHI_WATCH_IN & events)
- {
- FD_SET(fd, &readFdSet);
- }
-
- if (AVAHI_WATCH_OUT & events)
- {
- FD_SET(fd, &writeFdSet);
- }
-
- if (AVAHI_WATCH_ERR & events)
- {
- FD_SET(fd, &errorFdSet);
- }
-
- if (aMaxFd < fd)
- {
- aMaxFd = fd;
- }
-
- watch->mHappenedEvents = 0;
- }
-
- for (auto && timer : mTimers)
- {
- steady_clock::time_point absTimeout = timer->mAbsTimeout;
- steady_clock::time_point now = steady_clock::now();
-
- if (!timer->mEnabled)
- {
- continue;
- }
- if (absTimeout < now)
- {
- timeoutVal = microseconds(0);
- break;
- }
- else
- {
- timeoutVal = std::min(timeoutVal, duration_cast<microseconds>(absTimeout - now));
- }
- }
-
- timeout.tv_sec = (__time_t)(static_cast<uint64_t>(timeoutVal.count()) / kUsPerSec);
- timeout.tv_usec = (__suseconds_t)(static_cast<uint64_t>(timeoutVal.count()) % kUsPerSec);
-}
-
-void Poller::Process(const fd_set & readFdSet, const fd_set & writeFdSet, const fd_set & errorFdSet)
-{
- steady_clock::time_point now = steady_clock::now();
-
- for (auto && watch : mWatches)
- {
- int fd = watch->mFd;
- AvahiWatchEvent events = watch->mWatchEvents;
-
- watch->mHappenedEvents = 0;
-
- if ((AVAHI_WATCH_IN & events) && FD_ISSET(fd, &readFdSet))
- {
- watch->mHappenedEvents |= AVAHI_WATCH_IN;
- }
-
- if ((AVAHI_WATCH_OUT & events) && FD_ISSET(fd, &writeFdSet))
- {
- watch->mHappenedEvents |= AVAHI_WATCH_OUT;
- }
-
- if ((AVAHI_WATCH_ERR & events) && FD_ISSET(fd, &errorFdSet))
- {
- watch->mHappenedEvents |= AVAHI_WATCH_ERR;
- }
-
- if (watch->mHappenedEvents)
- {
- watch->mCallback(watch.get(), watch->mFd, static_cast<AvahiWatchEvent>(watch->mHappenedEvents), watch->mContext);
- }
- }
-
- for (auto && timer : mTimers)
- {
- if (!timer->mEnabled)
- {
- continue;
- }
- if (timer->mAbsTimeout <= now)
- {
- timer->mCallback(timer.get(), timer->mContext);
- }
- }
-}
-
-CHIP_ERROR MdnsAvahi::Init(MdnsAsyncReturnCallback initCallback, MdnsAsyncReturnCallback errorCallback, void * context)
-{
- CHIP_ERROR error = CHIP_NO_ERROR;
- int avahiError = 0;
-
- VerifyOrExit(initCallback != nullptr, error = CHIP_ERROR_INVALID_ARGUMENT);
- VerifyOrExit(errorCallback != nullptr, error = CHIP_ERROR_INVALID_ARGUMENT);
- VerifyOrExit(mClient == nullptr && mGroup == nullptr, 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;
-}
-
-CHIP_ERROR MdnsAvahi::SetHostname(const char * hostname)
-{
- CHIP_ERROR error = CHIP_NO_ERROR;
- int avahiRet;
-
- VerifyOrExit(mClient != nullptr, error = CHIP_ERROR_INCORRECT_STATE);
- avahiRet = avahi_client_set_host_name(mClient, hostname);
- if (avahiRet == AVAHI_ERR_ACCESS_DENIED)
- {
- ChipLogError(DeviceLayer, "Cannot set hostname on this system, continue anyway...");
- }
- else if (avahiRet != AVAHI_OK && avahiRet != AVAHI_ERR_NO_CHANGE)
- {
- error = CHIP_ERROR_INTERNAL;
- }
-
-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;
- mGroup = avahi_entry_group_new(client, HandleGroupState, this);
- if (mGroup == nullptr)
- {
- ChipLogError(DeviceLayer, "Failed to create avahi group: %s", avahi_strerror(avahi_client_errno(client)));
- mInitCallback(mAsyncReturnContext, CHIP_ERROR_OPEN_FAILED);
- }
- else
- {
- 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");
- if (mGroup != nullptr)
- {
- avahi_entry_group_reset(mGroup);
- avahi_entry_group_free(mGroup);
- }
- mGroup = avahi_entry_group_new(client, HandleGroupState, this);
- mPublishedServices.clear();
- if (mGroup == nullptr)
- {
- ChipLogError(DeviceLayer, "Failed to create avahi group: %s", avahi_strerror(avahi_client_errno(client)));
- mErrorCallback(mAsyncReturnContext, CHIP_ERROR_OPEN_FAILED);
- }
- else
- {
- 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 collission");
- mErrorCallback(mAsyncReturnContext, CHIP_ERROR_MDNS_COLLISSION);
- break;
- case AVAHI_ENTRY_GROUP_FAILURE:
- ChipLogError(DeviceLayer, "Avahi group internal failure %s",
- avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(mGroup))));
- mErrorCallback(mAsyncReturnContext, CHIP_ERROR_INTERNAL);
- break;
- case AVAHI_ENTRY_GROUP_UNCOMMITED:
- case AVAHI_ENTRY_GROUP_REGISTERING:
- break;
- }
-}
-
-CHIP_ERROR MdnsAvahi::PublishService(const MdnsService & service)
-{
- std::ostringstream keyBuilder;
- std::string key;
- std::string type = GetFullType(service.mType, service.mProtocol);
- CHIP_ERROR error = CHIP_NO_ERROR;
- AvahiStringList * text = nullptr;
- AvahiIfIndex interface =
- service.mInterface == INET_NULL_INTERFACEID ? AVAHI_IF_UNSPEC : static_cast<AvahiIfIndex>(service.mInterface);
-
- keyBuilder << service.mName << "." << type << service.mPort << "." << interface;
- key = keyBuilder.str();
- ChipLogProgress(DeviceLayer, "PublishService %s", key.c_str());
-
- if (mPublishedServices.find(key) == mPublishedServices.end())
- {
- SuccessOrExit(error = MakeAvahiStringListFromTextEntries(service.mTextEntries, service.mTextEntrySize, &text));
-
- mPublishedServices.emplace(key);
- VerifyOrExit(avahi_entry_group_add_service_strlst(mGroup, interface, ToAvahiProtocol(service.mAddressType),
- static_cast<AvahiPublishFlags>(0), service.mName, type.c_str(), nullptr,
- nullptr, service.mPort, text) == 0,
- error = CHIP_ERROR_INTERNAL);
- 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(mGroup, interface, ToAvahiProtocol(service.mAddressType),
- static_cast<AvahiPublishFlags>(0), service.mName, type.c_str(),
- nullptr, sstream.str().c_str()) == 0,
- error = CHIP_ERROR_INTERNAL);
- }
- }
- else
- {
- SuccessOrExit(error = MakeAvahiStringListFromTextEntries(service.mTextEntries, service.mTextEntrySize, &text));
-
- VerifyOrExit(avahi_entry_group_update_service_txt_strlst(mGroup, interface, ToAvahiProtocol(service.mAddressType),
- static_cast<AvahiPublishFlags>(0), service.mName, type.c_str(),
- nullptr, text) == 0,
- error = CHIP_ERROR_INTERNAL);
- }
-
- VerifyOrExit(avahi_entry_group_commit(mGroup) == 0, error = CHIP_ERROR_INTERNAL);
-
-exit:
- if (text != nullptr)
- {
- avahi_string_list_free(text);
- }
- if (error != CHIP_NO_ERROR)
- {
- ChipLogError(DeviceLayer, "Avahi publish service failed: %d", static_cast<int>(error));
- }
-
- return error;
-}
-
-CHIP_ERROR MdnsAvahi::StopPublish()
-{
- CHIP_ERROR error = CHIP_NO_ERROR;
-
- VerifyOrExit(avahi_entry_group_reset(mGroup) == 0, error = CHIP_ERROR_INTERNAL);
-exit:
- return error;
-}
-
-CHIP_ERROR MdnsAvahi::Browse(const char * type, MdnsServiceProtocol protocol, chip::Inet::IPAddressType addressType,
- chip::Inet::InterfaceId interface, MdnsBrowseCallback callback, void * context)
-{
- AvahiServiceBrowser * browser;
- BrowseContext * browseContext = static_cast<BrowseContext *>(chip::Platform::MemoryAlloc(sizeof(BrowseContext)));
- AvahiIfIndex avahiInterface = static_cast<AvahiIfIndex>(interface);
-
- browseContext->mInstance = this;
- browseContext->mContext = context;
- browseContext->mCallback = callback;
- if (interface == INET_NULL_INTERFACEID)
- {
- avahiInterface = AVAHI_IF_UNSPEC;
- }
-
- browser = avahi_service_browser_new(mClient, avahiInterface, ToAvahiProtocol(addressType), GetFullType(type, protocol).c_str(),
- nullptr, static_cast<AvahiLookupFlags>(0), HandleBrowse, browseContext);
- // Otherwise the browser will be freed in the callback
- if (browser == nullptr)
- {
- chip::Platform::MemoryFree(browseContext);
- }
-
- return browser == nullptr ? CHIP_ERROR_INTERNAL : CHIP_NO_ERROR;
-}
-
-MdnsServiceProtocol TruncateProtocolInType(char * type)
-{
- char * deliminator = strrchr(type, '.');
- MdnsServiceProtocol protocol = MdnsServiceProtocol::kMdnsProtocolUnknown;
-
- if (deliminator != NULL)
- {
- if (strcmp("._tcp", deliminator) == 0)
- {
- protocol = MdnsServiceProtocol::kMdnsProtocolTcp;
- *deliminator = 0;
- }
- else if (strcmp("._udp", deliminator) == 0)
- {
- protocol = MdnsServiceProtocol::kMdnsProtocolUdp;
- *deliminator = 0;
- }
- }
- return protocol;
-}
-
-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, CHIP_ERROR_INTERNAL);
- avahi_service_browser_free(browser);
- chip::Platform::MemoryFree(context);
- break;
- case AVAHI_BROWSER_NEW:
- ChipLogProgress(DeviceLayer, "Avahi browse: cache new");
- if (strcmp("local", domain) == 0)
- {
- MdnsService service;
-
- strncpy(service.mName, name, sizeof(service.mName));
- strncpy(service.mType, type, sizeof(service.mType));
- service.mName[kMdnsNameMaxSize] = 0;
- service.mType[kMdnsTypeMaxSize] = 0;
- service.mProtocol = TruncateProtocolInType(service.mType);
- service.mAddressType = ToAddressType(protocol);
- context->mServices.push_back(service);
- }
- break;
- case AVAHI_BROWSER_ALL_FOR_NOW:
- ChipLogProgress(DeviceLayer, "Avahi browse: all for now");
- context->mCallback(context->mContext, context->mServices.data(), context->mServices.size(), CHIP_NO_ERROR);
- avahi_service_browser_free(browser);
- chip::Platform::MemoryFree(context);
- break;
- case AVAHI_BROWSER_REMOVE:
- ChipLogProgress(DeviceLayer, "Avahi browse: remove");
- if (strcmp("local", domain) == 0)
- {
- std::remove_if(context->mServices.begin(), context->mServices.end(), [name, type](const MdnsService 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;
- }
-}
-
-CHIP_ERROR MdnsAvahi::Resolve(const char * name, const char * type, MdnsServiceProtocol protocol,
- chip::Inet::IPAddressType addressType, chip::Inet::InterfaceId interface,
- MdnsResolveCallback callback, void * context)
-{
- AvahiServiceResolver * resolver;
- AvahiIfIndex avahiInterface = static_cast<AvahiIfIndex>(interface);
- ResolveContext * resolveContext = static_cast<ResolveContext *>(chip::Platform::MemoryAlloc(sizeof(ResolveContext)));
- CHIP_ERROR error = CHIP_NO_ERROR;
-
- resolveContext->mInstance = this;
- resolveContext->mCallback = callback;
- resolveContext->mContext = context;
- if (interface == INET_NULL_INTERFACEID)
- {
- avahiInterface = AVAHI_IF_UNSPEC;
- }
- resolver = avahi_service_resolver_new(mClient, avahiInterface, ToAvahiProtocol(addressType), name,
- GetFullType(type, protocol).c_str(), nullptr, ToAvahiProtocol(addressType),
- static_cast<AvahiLookupFlags>(0), HandleResolve, resolveContext);
- // Otherwise the resolver will be freed in the callback
- if (resolver == nullptr)
- {
- error = CHIP_ERROR_INTERNAL;
- chip::Platform::MemoryFree(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)
-{
- ResolveContext * context = reinterpret_cast<ResolveContext *>(userdata);
- std::vector<TextEntry> textEntries;
-
- switch (event)
- {
- case AVAHI_RESOLVER_FAILURE:
- ChipLogError(DeviceLayer, "Avahi resolve failed");
- context->mCallback(context->mContext, nullptr, CHIP_ERROR_INTERNAL);
- break;
- case AVAHI_RESOLVER_FOUND:
- MdnsService result;
-
- result.mAddress.SetValue(chip::Inet::IPAddress());
- ChipLogError(DeviceLayer, "Avahi resolve found");
- strncpy(result.mName, name, sizeof(result.mName));
- strncpy(result.mType, type, sizeof(result.mType));
- result.mName[kMdnsNameMaxSize] = 0;
- result.mType[kMdnsTypeMaxSize] = 0;
- result.mProtocol = TruncateProtocolInType(result.mType);
- result.mPort = port;
- result.mAddressType = ToAddressType(protocol);
-
- if (address)
- {
- switch (address->proto)
- {
- case AVAHI_PROTO_INET:
- struct in_addr addr4;
-
- memcpy(&addr4, &(address->data.ipv4), sizeof(addr4));
- result.mAddress.SetValue(chip::Inet::IPAddress::FromIPv4(addr4));
- break;
- case AVAHI_PROTO_INET6:
- struct in6_addr addr6;
-
- memcpy(&addr6, &(address->data.ipv6), sizeof(addr6));
- result.mAddress.SetValue(chip::Inet::IPAddress::FromIPv6(addr6));
- 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();
-
- context->mCallback(context->mContext, &result, CHIP_NO_ERROR);
- break;
- }
-
- avahi_service_resolver_free(resolver);
- chip::Platform::MemoryFree(context);
-}
-
-MdnsAvahi::~MdnsAvahi()
-{
- if (mGroup)
- {
- avahi_entry_group_free(mGroup);
- }
- if (mClient)
- {
- avahi_client_free(mClient);
- }
-}
-
-void UpdateMdnsDataset(fd_set & readFdSet, fd_set & writeFdSet, fd_set & errorFdSet, int & maxFd, timeval & timeout)
-{
- MdnsAvahi::GetInstance().GetPoller().UpdateFdSet(readFdSet, writeFdSet, errorFdSet, maxFd, timeout);
-}
-
-void ProcessMdns(fd_set & readFdSet, fd_set & writeFdSet, fd_set & errorFdSet)
-{
- MdnsAvahi::GetInstance().GetPoller().Process(readFdSet, writeFdSet, errorFdSet);
-}
-
-CHIP_ERROR ChipMdnsInit(MdnsAsyncReturnCallback initCallback, MdnsAsyncReturnCallback errorCallback, void * context)
-{
- return MdnsAvahi::GetInstance().Init(initCallback, errorCallback, context);
-}
-
-CHIP_ERROR ChipMdnsSetHostname(const char * hostname)
-{
- return MdnsAvahi::GetInstance().SetHostname(hostname);
-}
-
-CHIP_ERROR ChipMdnsPublishService(const MdnsService * service)
-{
- return MdnsAvahi::GetInstance().PublishService(*service);
-}
-
-CHIP_ERROR ChipMdnsStopPublish()
-{
- return MdnsAvahi::GetInstance().StopPublish();
-}
-
-CHIP_ERROR ChipMdnsBrowse(const char * type, MdnsServiceProtocol protocol, chip::Inet::IPAddressType addressType,
- chip::Inet::InterfaceId interface, MdnsBrowseCallback callback, void * context)
-{
- return MdnsAvahi::GetInstance().Browse(type, protocol, addressType, interface, callback, context);
-}
-
-CHIP_ERROR ChipMdnsResolve(MdnsService * browseResult, chip::Inet::InterfaceId interface, MdnsResolveCallback callback,
- void * context)
-
-{
- CHIP_ERROR error;
-
- if (browseResult != nullptr)
- {
- error = MdnsAvahi::GetInstance().Resolve(browseResult->mName, browseResult->mType, browseResult->mProtocol,
- browseResult->mAddressType, interface, callback, context);
- }
- else
- {
- error = CHIP_ERROR_INVALID_ARGUMENT;
- }
- return error;
-}
-
-} // namespace Mdns
-} // namespace chip
projects / platform / upstream / connectedhomeip.git / commitdiff