blob: c0aa2038724fba59fc6b32c31c819f0692b58a40 [file] [log] [blame]
/*
*
* <COPYRIGHT>
*
* 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.
*/
/**
* @file
* This file implements AsyncDNSResolverSockets, the object that implements
* Asynchronous Domain Name System (DNS) resolution in InetLayer.
*
*/
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <support/CodeUtils.h>
#include <support/logging/CHIPLogging.h>
#include <InetLayer.h>
#if CHIP_SYSTEM_CONFIG_USE_SOCKETS
#if INET_CONFIG_ENABLE_DNS_RESOLVER && INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS
#include "AsyncDNSResolverSockets.h"
namespace chip {
namespace Inet {
/**
* The explicit initializer for the AsynchronousDNSResolverSockets class.
* This initializes the mutex and semaphore variables and creates the
* threads for handling the asynchronous DNS resolution.
*
* @param[in] aInet A pointer to the InetLayer object.
*
* @retval #INET_NO_ERROR if initialization is
* successful.
* @retval other appropriate POSIX network or OS error.
*/
INET_ERROR AsyncDNSResolverSockets::Init(InetLayer * aInet)
{
INET_ERROR err = INET_NO_ERROR;
int pthreadErr;
mInet = aInet;
mAsyncDNSQueueHead = NULL;
mAsyncDNSQueueTail = NULL;
pthreadErr = pthread_cond_init(&mAsyncDNSCondVar, NULL);
VerifyOrDie(pthreadErr == 0);
pthreadErr = pthread_mutex_init(&mAsyncDNSMutex, NULL);
VerifyOrDie(pthreadErr == 0);
// Create the thread pool for asynchronous DNS resolution.
for (int i = 0; i < INET_CONFIG_DNS_ASYNC_MAX_THREAD_COUNT; i++)
{
pthreadErr = pthread_create(&mAsyncDNSThreadHandle[i], NULL, &AsyncDNSThreadRun, this);
VerifyOrDie(pthreadErr == 0);
}
return err;
}
/**
* This is the explicit deinitializer of the AsyncDNSResolverSockets class
* and it takes care of shutting the threads down and destroying the mutex
* and semaphore variables.
*
* @retval #INET_NO_ERROR if shutdown is successful.
* @retval other appropriate POSIX network or OS error.
*/
INET_ERROR AsyncDNSResolverSockets::Shutdown(void)
{
INET_ERROR err = INET_NO_ERROR;
int pthreadErr;
AsyncMutexLock();
mInet->State = InetLayer::kState_ShutdownInProgress;
pthreadErr = pthread_cond_broadcast(&mAsyncDNSCondVar);
VerifyOrDie(pthreadErr == 0);
AsyncMutexUnlock();
// Have the chip thread join the thread pool for asynchronous DNS resolution.
for (int i = 0; i < INET_CONFIG_DNS_ASYNC_MAX_THREAD_COUNT; i++)
{
pthreadErr = pthread_join(mAsyncDNSThreadHandle[i], NULL);
VerifyOrDie(pthreadErr == 0);
}
pthreadErr = pthread_mutex_destroy(&mAsyncDNSMutex);
VerifyOrDie(pthreadErr == 0);
pthreadErr = pthread_cond_destroy(&mAsyncDNSCondVar);
VerifyOrDie(pthreadErr == 0);
return err;
}
/**
* This method prepares a DNSResolver object prior to asynchronous resolution.
*
* @param[in] resolver A reference to an allocated DNSResolver object.
*
* @param[in] hostName A pointer to a C string representing the host name
* to be queried.
* @param[in] hostNameLen The string length of host name.
* @param[in] options An integer value controlling how host name address
* resolution is performed. Values are from the #DNSOptions
* enumeration.
* @param[in] maxAddrs The maximum number of addresses to store in the DNS
* table.
* @param[in] addrArray A pointer to the DNS table.
* @param[in] onComplete A pointer to the callback function when a DNS
* request is complete.
* @param[in] appState A pointer to the application state to be passed to
* onComplete when a DNS request is complete.
*
* @retval INET_NO_ERROR if a DNS request is handled
* successfully.
*
*/
INET_ERROR AsyncDNSResolverSockets::PrepareDNSResolver(DNSResolver & resolver, const char * hostName, uint16_t hostNameLen,
uint8_t options, uint8_t maxAddrs, IPAddress * addrArray,
DNSResolver::OnResolveCompleteFunct onComplete, void * appState)
{
INET_ERROR err = INET_NO_ERROR;
memcpy(resolver.asyncHostNameBuf, hostName, hostNameLen);
resolver.asyncHostNameBuf[hostNameLen] = 0;
resolver.MaxAddrs = maxAddrs;
resolver.NumAddrs = 0;
resolver.DNSOptions = options;
resolver.AddrArray = addrArray;
resolver.AppState = appState;
resolver.OnComplete = onComplete;
resolver.asyncDNSResolveResult = INET_NO_ERROR;
resolver.mState = DNSResolver::kState_Active;
resolver.pNextAsyncDNSResolver = NULL;
return err;
}
/**
* Enqueue a DNSResolver object for asynchronous IP address resolution of a specified hostname.
*
* @param[in] resolver A reference to the DNSResolver object.
*
* @retval #INET_NO_ERROR if a DNS request is queued
* successfully.
* @retval #INET_ERROR_NO_MEMORY if the Inet layer resolver pool
* is full.
* @retval other appropriate POSIX network or OS error.
*
*/
INET_ERROR AsyncDNSResolverSockets::EnqueueRequest(DNSResolver & resolver)
{
INET_ERROR err = INET_NO_ERROR;
int pthreadErr;
AsyncMutexLock();
// Add the DNSResolver object to the queue.
if (mAsyncDNSQueueHead == NULL)
{
mAsyncDNSQueueHead = &resolver;
}
if (mAsyncDNSQueueTail != NULL)
{
mAsyncDNSQueueTail->pNextAsyncDNSResolver = &resolver;
}
mAsyncDNSQueueTail = &resolver;
pthreadErr = pthread_cond_signal(&mAsyncDNSCondVar);
VerifyOrDie(pthreadErr == 0);
AsyncMutexUnlock();
return err;
}
/**
* Dequeue a DNSResolver object from the queue if there is one.
* Make the worker thread block if there is no item in the queue.
*
*/
INET_ERROR AsyncDNSResolverSockets::DequeueRequest(DNSResolver ** outResolver)
{
INET_ERROR err = INET_NO_ERROR;
int pthreadErr;
AsyncMutexLock();
// block until there is work to do or we detect a shutdown
while ((mAsyncDNSQueueHead == NULL) && (mInet->State == InetLayer::kState_Initialized))
{
pthreadErr = pthread_cond_wait(&mAsyncDNSCondVar, &mAsyncDNSMutex);
VerifyOrDie(pthreadErr == 0);
}
ChipLogDetail(Inet, "Async DNS worker thread woke up.");
// on shutdown, return NULL. Otherwise, pop the head of the DNS request queue
if (mInet->State != InetLayer::kState_Initialized)
{
*outResolver = NULL;
}
else
{
*outResolver = const_cast<DNSResolver *>(mAsyncDNSQueueHead);
mAsyncDNSQueueHead = mAsyncDNSQueueHead->pNextAsyncDNSResolver;
if (mAsyncDNSQueueHead == NULL)
{
// Queue is empty
mAsyncDNSQueueTail = NULL;
}
}
AsyncMutexUnlock();
return err;
}
/**
* Cancel an outstanding DNS query that may still be active.
*
* @param[in] resolver A reference to the DNSResolver object.
*/
INET_ERROR AsyncDNSResolverSockets::Cancel(DNSResolver & resolver)
{
INET_ERROR err = INET_NO_ERROR;
AsyncMutexLock();
resolver.mState = DNSResolver::kState_Canceled;
AsyncMutexUnlock();
return err;
}
void AsyncDNSResolverSockets::UpdateDNSResult(DNSResolver & resolver, struct addrinfo * inLookupRes)
{
resolver.NumAddrs = 0;
for (struct addrinfo * addr = inLookupRes; addr != NULL && resolver.NumAddrs < resolver.MaxAddrs;
addr = addr->ai_next, resolver.NumAddrs++)
{
resolver.AddrArray[resolver.NumAddrs] = IPAddress::FromSockAddr(*addr->ai_addr);
}
}
void AsyncDNSResolverSockets::Resolve(DNSResolver & resolver)
{
struct addrinfo gaiHints;
struct addrinfo * gaiResults = NULL;
int gaiReturnCode;
// Configure the hints argument for getaddrinfo()
resolver.InitAddrInfoHints(gaiHints);
// Call getaddrinfo() to perform the name resolution.
gaiReturnCode = getaddrinfo(resolver.asyncHostNameBuf, NULL, &gaiHints, &gaiResults);
// Mutex protects the read and write operation on resolver->mState
AsyncMutexLock();
// Process the return code and results list returned by getaddrinfo(). If the call
// was successful this will copy the resultant addresses into the caller's array.
resolver.asyncDNSResolveResult = resolver.ProcessGetAddrInfoResult(gaiReturnCode, gaiResults);
// Set the DNS resolver state.
resolver.mState = DNSResolver::kState_Complete;
// Release lock.
AsyncMutexUnlock();
return;
}
/* Event handler function for asynchronous DNS notification */
void AsyncDNSResolverSockets::DNSResultEventHandler(chip::System::Layer * aLayer, void * aAppState, chip::System::Error aError)
{
DNSResolver * resolver = static_cast<DNSResolver *>(aAppState);
if (resolver)
{
resolver->HandleAsyncResolveComplete();
}
}
void AsyncDNSResolverSockets::NotifyChipThread(DNSResolver * resolver)
{
// Post work item via Timer Event for the chip thread
chip::System::Layer & lSystemLayer = resolver->SystemLayer();
ChipLogDetail(Inet, "Posting DNS completion event to chip thread.");
lSystemLayer.ScheduleWork(AsyncDNSResolverSockets::DNSResultEventHandler, resolver);
}
void * AsyncDNSResolverSockets::AsyncDNSThreadRun(void * args)
{
INET_ERROR err = INET_NO_ERROR;
AsyncDNSResolverSockets * asyncResolver = static_cast<AsyncDNSResolverSockets *>(args);
while (true)
{
DNSResolver * request = NULL;
// Dequeue a DNSResolver for resolution. This function would block until there
// is an item in the queue or shutdown has been called.
err = asyncResolver->DequeueRequest(&request);
// If shutdown has been called, DeQueue would return with an empty request.
// In that case, break out of the loop and exit thread.
VerifyOrExit(err == INET_NO_ERROR && request != NULL, );
if (request->mState != DNSResolver::kState_Canceled)
{
asyncResolver->Resolve(*request);
}
asyncResolver->NotifyChipThread(request);
}
exit:
ChipLogDetail(Inet, "Async DNS worker thread exiting.");
return NULL;
}
void AsyncDNSResolverSockets::AsyncMutexLock(void)
{
int pthreadErr;
pthreadErr = pthread_mutex_lock(&mAsyncDNSMutex);
VerifyOrDie(pthreadErr == 0);
}
void AsyncDNSResolverSockets::AsyncMutexUnlock(void)
{
int pthreadErr;
pthreadErr = pthread_mutex_unlock(&mAsyncDNSMutex);
VerifyOrDie(pthreadErr == 0);
}
} // namespace Inet
} // namespace chip
#endif // INET_CONFIG_ENABLE_DNS_RESOLVER && INET_CONFIG_ENABLE_ASYNC_DNS_SOCKETS
#endif // CHIP_SYSTEM_CONFIG_USE_SOCKETS