blob: aa7f0f6737aa899c1117357da885375b7bad4cc7 [file] [log] [blame]
/*
*
* Copyright (c) 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.
*
* 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.
*/
#pragma once
#include <lib/dnssd/platform/Dnssd.h>
#include <lib/support/CHIPMemString.h>
#include <lib/support/CodeUtils.h>
#include <mdns.h>
namespace chip {
namespace Dnssd {
enum class ContextType
{
Browse = 1,
Resolve,
Reserved,
};
struct GenericContext
{
ContextType mContextType;
char mType[kDnssdTypeMaxSize + 1];
DnssdServiceProtocol mProtocol;
Inet::InterfaceId mInterfaceId;
void * mCbContext;
DnssdService * mService = nullptr;
size_t mServiceSize = 0;
GenericContext(ContextType ctxType, const char * type, DnssdServiceProtocol protocol, Inet::InterfaceId ifId, void * cbCtx) :
mContextType(ctxType), mProtocol(protocol), mInterfaceId(ifId), mCbContext(cbCtx)
{
Platform::CopyString(mType, type);
}
~GenericContext()
{
if (mService && mServiceSize > 0)
{
for (size_t serviceIndex = 0; serviceIndex < mServiceSize; serviceIndex++)
{
if (mService[serviceIndex].mTextEntries)
{
chip::Platform::MemoryFree(mService[serviceIndex].mTextEntries);
}
}
chip::Platform::MemoryFree(mService);
}
}
};
struct BrowseContext : public GenericContext
{
DnssdBrowseCallback mBrowseCb;
Inet::IPAddressType mAddressType;
mdns_search_once_t * mPtrQueryHandle;
mdns_result_t * mPtrQueryResult = nullptr;
BrowseContext(const char * type, DnssdServiceProtocol protocol, Inet::InterfaceId ifId, mdns_search_once_t * queryHandle,
Inet::IPAddressType addrType, DnssdBrowseCallback cb, void * cbCtx) :
GenericContext(ContextType::Browse, type, protocol, ifId, cbCtx),
mBrowseCb(cb), mAddressType(addrType), mPtrQueryHandle(queryHandle)
{}
~BrowseContext()
{
if (mPtrQueryResult)
{
mdns_query_results_free(mPtrQueryResult);
}
if (mPtrQueryHandle)
{
mdns_query_async_delete(mPtrQueryHandle);
}
}
};
struct ResolveContext : public GenericContext
{
char mInstanceName[Common::kInstanceNameMaxLength + 1];
DnssdResolveCallback mResolveCb;
Inet::IPAddress * mAddresses = nullptr;
size_t mAddressCount = 0;
mdns_search_once_t * mSrvQueryHandle;
mdns_result_t * mSrvQueryResult = nullptr;
mdns_result_t * mAddrQueryResult = nullptr;
bool mSrvAddrQueryFinished = false;
mdns_search_once_t * mTxtQueryHandle;
mdns_result_t * mTxtQueryResult = nullptr;
bool mTxtQueryFinished = false;
ResolveContext(DnssdService * service, Inet::InterfaceId ifId, mdns_search_once_t * srvQuery, mdns_search_once_t * txtQuery,
DnssdResolveCallback cb, void * cbCtx) :
GenericContext(ContextType::Resolve, service->mType, service->mProtocol, ifId, cbCtx),
mResolveCb(cb), mSrvQueryHandle(srvQuery), mTxtQueryHandle(txtQuery)
{
Platform::CopyString(mInstanceName, service->mName);
}
~ResolveContext()
{
if (mAddresses)
{
chip::Platform::MemoryFree(mAddresses);
}
if (mSrvQueryResult)
{
mdns_query_results_free(mSrvQueryResult);
}
if (mAddrQueryResult && mAddrQueryResult != mSrvQueryResult)
{
mdns_query_results_free(mAddrQueryResult);
}
if (mTxtQueryResult)
{
mdns_query_results_free(mTxtQueryResult);
}
if (mSrvQueryHandle)
{
mdns_query_async_delete(mSrvQueryHandle);
}
if (mTxtQueryHandle)
{
mdns_query_async_delete(mTxtQueryHandle);
}
}
};
CHIP_ERROR EspDnssdInit(DnssdAsyncReturnCallback initCallback, DnssdAsyncReturnCallback errorCallback, void * context);
CHIP_ERROR EspDnssdPublishService(const DnssdService * service, DnssdPublishCallback callback, void * context);
CHIP_ERROR EspDnssdRemoveServices();
CHIP_ERROR EspDnssdBrowse(const char * type, DnssdServiceProtocol protocol, chip::Inet::IPAddressType addressType,
chip::Inet::InterfaceId interface, DnssdBrowseCallback callback, void * context,
intptr_t * browseIdentifier);
CHIP_ERROR EspDnssdResolve(DnssdService * service, chip::Inet::InterfaceId interface, DnssdResolveCallback callback,
void * context);
} // namespace Dnssd
} // namespace chip