// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// dns.cpp - the main client module of the DNS.
//
#include <e32math.h>
#include <in_sock.h>
#include <in6_opt.h>
#include "dns.h"
#include "dnd.hrh" // EDndDump
#include <networking/dnd_err.h>
#include "engine.h"
#include "servers.h"
#include "cache.h"
#include "inet6log.h"
#ifdef LLMNR_ENABLED
# include "llmnrresponder.h"
#endif
#include "dnd_ini.h"
#ifdef EXCLUDE_SYMBIAN_DNS_PUNYCODE
#undef SYMBIAN_DNS_PUNYCODE
#endif //EXCLUDE_SYMBIAN_DNS_PUNYCODE
class CDnsService : public CDndDnsclient
{
public:
CDnsService(CDndEngine &aControl, MDnsServerManager &aServerManager) : CDndDnsclient(aControl, aServerManager) {}
void ConstructL();
~CDnsService();
virtual void ConfigurationChanged();
TInt SetHostName(TUint32 aId, const THostName &aName);
TInt GetHostName(TUint32 aId, THostName &aName, MDnsResolver &aCallback);
TInt GetByAddress(TUint32 aId, const TInetAddr &aAddr, TInt aNext, THostName &aName);
TInt GetByName(TUint32 aId, const THostName &aName, TInt aNext, TInetAddr &aAddr);
private:
#ifdef LLMNR_ENABLED
CDndLlmnrResponder *iLlmnrResponder; //< Pointer to the LLMNR responder object
#endif
TUint32 GetNetId(TUint32 aIndex);
TInetAddressInfo *GetAddressList(TInt &aN);
};
void CDnsService::ConstructL()
{
CDndDnsclient::ConstructL();
#ifdef LLMNR_ENABLED
iLlmnrResponder = new (ELeave) CDndLlmnrResponder(iControl, iServerManager, iHostNames);
iLlmnrResponder->ConstructL();
#endif
}
CDnsService::~CDnsService()
{
#ifdef LLMNR_ENABLED
delete iLlmnrResponder;
#endif
}
void CDnsService::ConfigurationChanged()
{
#ifdef LLMNR_ENABLED
iLlmnrResponder->ConfigurationChanged();
#endif
}
//
// Gateway hostname processing to the responder
//
TInt CDnsService::SetHostName(TUint32 aId, const THostName &aName)
{
const TInt res = iHostNames.Map(aId, aName);
#ifdef LLMNR_ENABLED
return res == KErrNone ? iLlmnrResponder->SetHostName(aId, iHostNames.Find(aId)) : res;
#else
return res;
#endif
}
TInt CDnsService::GetHostName(TUint32 aId, THostName &aName, MDnsResolver &aCallback)
{
aName = iHostNames.Find(aId);
#ifdef LLMNR_ENABLED
return iLlmnrResponder->GetHostName(aId, aCallback);
#else
(void)aCallback;
return KErrNone;
#endif
}
TUint32 CDnsService::GetNetId(TUint32 aIndex)
{
TPckgBuf<TSoInetIfQuery> opt;
opt().iIndex = aIndex;
return iControl.iSocket.GetOpt(KSoInetIfQueryByIndex, KSolInetIfQuery, opt) == KErrNone
? opt().iZone[15] : 0;
}
TInetAddressInfo *CDnsService::GetAddressList(TInt &aN)
/**
* Returns a list of all current addresses.
*
* @retval aN The number of addresses (if return is non-NULL).
* @return The address list, or NULL if not available.
*
* The returned address list must be freed by the caller
* as "delete[] list".
*/
{
TPtr8 empty(NULL, 0);
aN = iControl.iSocket.GetOpt(KSoInetAddressInfo, KSolInetIfQuery, empty);
if (aN <= 0)
return NULL;
TInetAddressInfo *p = new TInetAddressInfo[aN];
if (p == NULL)
return NULL; // No memory available.
TPtr8 opt((TUint8 *)p, aN*sizeof(TInetAddressInfo));
aN = iControl.iSocket.GetOpt(KSoInetAddressInfo, KSolInetIfQuery, opt);
if (aN < 0)
aN = 0;
else
aN = opt.Length() / (TInt)sizeof(TInetAddressInfo);
return p;
}
TInt CDnsService::GetByAddress(TUint32 /*aId*/, const TInetAddr &aAddr, TInt /*aNext*/, THostName &aName)
/**
* Returns the local hostname, if address is my own.
*/
{
TPckgBuf<TSoInetIfQuery> opt;
opt().iSrcAddr = aAddr;
if (iControl.iSocket.GetOpt(KSoInetIfQueryBySrcAddr, KSolInetIfQuery, opt) != KErrNone)
return KErrNotFound;
aName = iHostNames.Find(opt().iZone[15]); // Locate hostname for network id.
return (aName.Length() > 0) ? KErrNone : KErrNotFound;
}
TInt CDnsService::GetByName(TUint32 aId, const THostName &aName, TInt /*aNext*/, TInetAddr &aAddr)
/**
* Returns one of my own addresses, if the hostname is local.
*/
{
const TDesC &name = iHostNames.Find(aId);
if (aName.Length() > 0 && name.CompareF(aName) != 0)
return KErrNotFound; // The query name is not a local host.
//
// Locate a local addres from some interface within the specific network.
//
TInt N;
TInetAddressInfo *list = GetAddressList(N);
if (list == NULL)
return KErrNotFound;
TUint32 iface = 0;
TUint32 netid = 0;
TInt scope = -1;
TInt best = 0;
for (TInt i = 0; i < N; ++i)
{
if (list[i].iState != TInetAddressInfo::EAssigned)
continue;
if (list[i].iInterface != iface)
{
iface = list[i].iInterface;
netid = GetNetId(iface);
}
if (netid != aId)
continue; // Not this address.
if (list[i].iAddress.Scope() > scope)
{
scope = list[i].iAddress.Scope();
best = i;
}
}
aAddr.SetAddress(list[best].iAddress);
aAddr.SetScope(list[best].iScopeId);
delete[] list;
return scope < 0 ? KErrNotFound : KErrNone;
}
//
//
CDndDnsclient *CDndDnsclient::NewL(CDndEngine &aControl, MDnsServerManager &aServerManager)
{
LOG(Log::Printf(_L("CDndDnsclient::NewL()")));
CDnsService *const dns = new (ELeave) CDnsService(aControl, aServerManager);
CleanupStack::PushL(dns);
dns->ConstructL();
CleanupStack::Pop();
return dns;
}
CDndDnsclient::CDndDnsclient(CDndEngine &aControl, MDnsServerManager &aServerManager)
: CDnsSocket(aControl.GetConfig().iEDNS0), iControl(aControl), iServerManager(aServerManager)
{
}
void CDndDnsclient::ConstructL()
{
LOG(Log::Printf(_L("CDndDnsclient::ConstructL() size=%d"), (TInt)sizeof(*this)));
CDnsSocket::ConstructL();
iCache = new (ELeave) CDndCache();
iCache->ConstructL();
TPtrC localhost;
if(iControl.FindVar(DND_INI_HOST, DND_INI_HOSTNAME, localhost))
(void)iHostNames.Reset(localhost);
else
(void)iHostNames.Reset(KDndIni_Hostname);
}
void CDndDnsclient::HandleCommandL(TInt aCommand)
{
#ifdef _LOG
switch(aCommand)
{
case EDndDump:
if (iCache)
iCache->Dump(iControl);
break;
default:
break;
}
#endif
if (aCommand == EDndFlush)
iCache->Flush();
}
CDndDnsclient::~CDndDnsclient()
{
DeactivateSocket();
// Just to be sure, cancel server list notifys (if any)
// (this means that SERVER MANAGER MUST NOT BE DELETED
// before this object!)
for (TUint i = 0; i < KDndNumRequests; i++)
iServerManager.CloseList(iDndReqData[i].iFilter);
delete iCache;
}
// CDndDnsclient::CheckAddress
// ***************************
TInt CDndDnsclient::CheckAddress(const TInetAddr &aDestination)
{
TPckgBuf<TSoInetIfQuery> opt;
opt().iDstAddr = aDestination;
const TInt err = iControl.iSocket.GetOpt(KSoInetIfQueryByDstAddr, KSolInetIfQuery, opt);
if (err == KErrNone && TInetAddr::Cast(opt().iSrcAddr).IsUnspecified())
return KErrNotFound; // No route or source address.
return err;
}
// TDndReqData::PickDefaultServer
// ********************************
TBool TDndReqData::PickDefaultServer()
{
TInetAddr tmp;
TBool ret = FALSE;
if (iCurrentServer == 0)
ret = iOwner->iServerManager.OpenList(iFilter, this) > 0;
iOwner->iCache->GetServerAddress(iOwner->iServerManager.NameSpace(iFilter, iCurrentServer), tmp);
iFilter.iServerId = iOwner->iServerManager.ServerId(tmp);
iCurrentServer = iOwner->iServerManager.Next(iFilter, 0);
#ifdef _LOG
if (iCurrentServer)
Log::Printf(_L("\t\tDNS session [%u] default nameserver (id=%d) assigned"), (TInt)this, (TInt)iCurrentServer);
else
Log::Printf(_L("\t\tDNS session [%u] no nameservers available for this session"), (TInt)this);
#endif
return ret || iCurrentServer != 0;
}
// TDndReqData::PickNewServer
// ****************************
TBool TDndReqData::PickNewServer()
{
if (iCurrentServer == 0)
iOwner->iServerManager.BuildServerList();
iCurrentServer = iOwner->iServerManager.Next(iFilter, iCurrentServer);
#ifdef _LOG
if (iCurrentServer)
Log::Printf(_L("\t\tDNS session [%u] next nameserver (id=%d) assigned"), (TInt)this, (TInt)iCurrentServer);
else
Log::Printf(_L("\t\tDNS session [%u] next, no alternate nameservers to assign"), (TInt)this);
#endif
return iCurrentServer != 0;
}
void TDndReqData::ServerListComplete(const TDnsServerFilter &aFilter, TInt aResult)
{
if (&aFilter == &iFilter)
{
iCurrentServer = iOwner->iServerManager.Next(iFilter, 0);
if (iIsReqPending)
{
if (aResult == KErrNone)
{
if (PickDefaultServer())
{
iOwner->ReSend(*this, NULL);
aResult = KDnsNotify_HAVE_SERVERLIST;
}
else
aResult = KErrDndServerUnusable;
}
SendResponse(aResult);
}
}
}
// CDndDnsclient::OpenSession
// **************************
/**
// A session is internally represented by a TDndReqData. Find an unused
// entry and assign it. Unused entry is recognized by it having no
// callback function (= NULL).
*/
MDnsSession *CDndDnsclient::OpenSession(MDnsResolver *const aCallback)
{
TUint i;
//
// Locate available TDndReqData entry...
//
for (i = 0;; ++i)
{
if (i >= KDndNumRequests)
return NULL; // No "sessions" available
// For now, assume the slot is available, if no callback has been installed
if (iDndReqData[i].iCallback == NULL)
break;
}
TDndReqData &rq = iDndReqData[i];
rq.iCallback = aCallback;
rq.iOwner = this;
iSessionCount++; // Count each open session as "activity".*/
#ifdef _LOG
Log::Printf(_L("\t\tDNS session [%u] CDndDnsclient::OpenSession Session count is %d"), (TInt)this,iSessionCount);
#endif
return &rq;
}
void CDndDnsclient::Error(const TInetAddr &aServer, TInt /*aError*/)
{
const TUint server_id = iServerManager.ServerId(aServer);
if (server_id == 0)
return; // -- nothing to do, address not registered as a server
//
// Try to notify all sessions currently using this server
//
for (TUint i = 0; i < KDndNumRequests; ++i)
{
TDndReqData &rq = iDndReqData[i];
// For now, assume the slot is in used, if callback has been installed
if (rq.iCallback == NULL)
continue;
if (rq.iCurrentServer == server_id)
rq.SendResponse(KErrDndServerUnusable);
}
}
// TDndReqData::Close
// ******************
void TDndReqData::Close()
{
CancelQuery();
iCallback = NULL;
if (iRecord)
{
iRecord->Unlock(this);
iRecord = NULL;
}
iOwner->iServerManager.CloseList(iFilter);
// If this was the last active session, then
// cancel all requests
// Also deactivate sockets based on session, e.f query is ongoing and session comes to an end
ASSERT(iOwner->iSessionCount > 0);
if(iOwner->iSessionCount > 0)
{
if (--iOwner->iSessionCount == 0)
{
LOG(Log::Printf(_L("TDndReqData::Close - session count zero deactivating socket = %d, "), iOwner->iSessionCount));
iOwner->DeactivateSocket();
}
}
else
{
// For safety and cleaning purpose
iOwner->DeactivateSocket();
}
LOG(Log::Printf(_L("TDndReqData::Close - current session count = %d"), iOwner->iSessionCount));
}
// TDndReqData::NewQuery
// ***********************
TInt TDndReqData::NewQuery(const TDnsMessage &aQuery, TDnsServerScope aServerScope, TUint32 aFlags)
{
iIsReqPending = FALSE;
iIsNewQuery = TRUE;
iIsUsingTCP = 0;
iQdCount = 1;
iFlags = aFlags;
iFilter.iServerScope = aServerScope;
iFilter.iServerId = 0;
iNetworkId = aQuery.iId; // Get the networkId information from the Query.
#ifdef SYMBIAN_DNS_PUNYCODE
if( (aQuery.iScope & 0x80) == 0x80 )
{
iIdnEnabled = 1;
iQuestion.EnableIdn(ETrue);
}
else
{
iIdnEnabled = 0;
iQuestion.EnableIdn(EFalse);
}
#endif //SYMBIAN_DNS_PUNYCODE
switch (aQuery.iType)
{
case KDnsRequestType_GetByName:
case KDnsRequestType_GetByAddress:
{
const TNameRecord &query = aQuery.NameRecord();
if (aQuery.iType == KDnsRequestType_GetByName)
{
iFilter.iLockId = aQuery.iId;
iFilter.iLockType = KIp6AddrScopeNetwork;
#ifdef SYMBIAN_DNS_PUNYCODE
TInt err = iQuestion.SetName(query.iName);
if( err != KErrNone)
{
return err;
}
#else
iQuestion.SetName(query.iName);
#endif // SYMBIAN_DNS_PUNYCODE
}
else
{
iOwner->iServerManager.LockByAddress(TInetAddr::Cast(query.iAddr), aQuery.iId, iFilter);
#ifdef SYMBIAN_DNS_PUNYCODE
TInt err = iQuestion.SetName(TInetAddr::Cast(query.iAddr));
if( err != KErrNone)
{
return err;
}
#else
iQuestion.SetName(TInetAddr::Cast(query.iAddr));
#endif // SYMBIAN_DNS_PUNYCODE
}
}
break;
case KDnsRequestType_TDnsQuery:
{
const TDnsQuery &query = aQuery.Query();
iQuestion.Copy(query.Data());
iFilter.iLockId = aQuery.iId;
iFilter.iLockType = KIp6AddrScopeNetwork;
}
break;
default:
return KErrNotSupported;
}
iCurrentServer = 0;
//
// For forward query, the Scope identifier of the aQuery.iAddr is the network id
// For pointer query, if the address is not of network scope, then need to find
// the network id based on the scope id... (fix later). -- msa
iOpcode = EDnsOpcode_QUERY; // Only EStandard supported! (EInverse is not same as PTR query!!!)
if (iRecord)
{
iRecord->Unlock(this);
iRecord = NULL;
}
return KErrNone;
}
// TDndReqData::CancelQuery
// **************************
void TDndReqData::CancelQuery()
{
iIsReqPending = FALSE;
Cancel();
iOwner->iServerManager.CloseList(iFilter);
}
// TDndReqData::DoNext
// *********************
/**
// @retval aReply returns the requested Resource Record value, if KErrNone return
// @param aNext the index of the value to be returned. 0 is the index of the first value
// @returns
// @li KErrNotFound, if there is no value at specified index
// @li KErrDndCache, if the reply from DNS stored in cache was corrupt
// @li KErrNone, if value successfully returned
*/
TInt TDndReqData::DoNext(TDnsMessageBuf &aReply, TInt aNext) const
{
if (iRecord == NULL)
return KErrNotFound;
TInt ret = iRecord->ErrorCode();
if (ret < 0)
return ret; // No usable record present
TDndRR tempRR(iRecord->Reply());
#ifdef SYMBIAN_DNS_PUNYCODE
tempRR.iIdnEnabled = TBool(iIdnEnabled);
#endif //SYMBIAN_DNS_PUNYCODE
const TInet6HeaderDNS &hdr = iRecord->Header();
TInt answerCount = hdr.ANCOUNT();
ret = tempRR.FindRR(iRecord->AnswerOffset(), answerCount, iQuestion.QType(), iQuestion.QClass(), aNext);
if (ret < 0)
{
if (ret == KErrDndCache)
iRecord->Invalidate();
return ret;
}
TInetAddr *addr = NULL;
switch (aReply().iType)
{
case KDnsRequestType_GetByName:
case KDnsRequestType_GetByAddress:
{
TNameRecord &reply = aReply().NameRecord();
aReply.SetLength(aReply().HeaderSize() + sizeof(reply));
if (hdr.AA())
reply.iFlags |= EDnsAuthoritive;
ret = GetResponse(tempRR, reply);
reply.iFlags |= EDnsServer | (iIsFromCache ? EDnsCache : 0);
addr = &TInetAddr::Cast(reply.iAddr);
break;
}
#ifndef NO_DNS_QUERY_SUPPORT
case KDnsRequestType_TDnsQuery:
ret = tempRR.GetResponse(aReply, &addr);
break;
#endif
default:
return KErrNotSupported;
}
if (ret < 0)
return ret; // Some error detected!
if (addr)
{
// Reply contains a TInetAddr. This needs some special processing
// Supplement IPv6 addresses with the scope value
// (Should do the same with IPv4 after converting to IPv4 mapped?)
if (addr->Family() == KAfInet)
addr->ConvertToV4Mapped();
if (addr->Family() == KAfInet6)
{
const TInt scope_level = addr->Ip6Address().Scope();
// Add the scope id only for addresses with larger than node
// local scope (this leaves the scope id as zero, if a loopback
// address is returned from the name server (The id of the node
// local scope is the interface index and non-zero value would
// bind loopback destination to real interface instead of internal
// loopback interface).
if (scope_level > KIp6AddrScopeNodeLocal)
addr->SetScope(iOwner->iServerManager.Scope(iRecord->Server(), *addr));
#ifdef LLMNR_ENABLED
if(iOwner->iControl.GetConfig().iLlmnrLlOnly) // accept only linklocal replies to LLMNR queries
if (iFilter.iServerScope == EDnsServerScope_MC_LOCAL)
{
// Check compliance w. link-local addressing requirements (ipv6/ipv4)
if (scope_level != KIp6AddrScopeLinkLocal)
return KErrNotFound;
}
#endif
//
// A backward compatibility hack: if address is IPv4 global address
// and the network scope in the query matches the scope of the address,
// then convert the returned address into old KAfInet format (and lose
// lose the scope id).
if (addr->IsV4Mapped() &&
addr->Scope() == aReply().iId &&
scope_level == KIp6AddrScopeNetwork)
addr->SetAddress(addr->Address());
}
}
return KErrNone;
}
// TDndReqData::DoError
// **********************
/**
// If a session has a DNS reply in cache associated with it, then
// set the state of this reply to indicated error code.
//
// @param aError the error code to be stored
// @param aTLL the new "Time To Live" for the record (in seconds). The
// record (and error state) will expire after this time.
*/
void TDndReqData::DoError(TInt aError, TUint aTTL)
{
if (aError >= 0)
return; // Only errors can be set!
if (iRecord == NULL)
return;
iRecord->FillErrorCode(aError, aTTL);
}
// TDndReqData::DoQueryL
// ***********************
/**
// Activate a query of specified type for the loaded query information
// (enable RecvReply callback). Note: the callback may occur already within call!
//
// @param aRequestTime is the time when the request is received from the application
// @param aQType type of the query (all queries assume IN class)
// @returns
// @li < 0, serious error, (resolving process should be aborted)
// @li = 0, reply found from cache (reply callback has been called)
// @li = 1, DNS Query message has been queued for transmission
// @execption
// LEAVE on any serious error (resolving process should be aborted)
*/
TInt TDndReqData::DoQueryL(const TTime &aRequestTime, const EDnsQType aQType)
{
// -- class is now always IN,
// -- should only look from cache if aQType is not a "wildcard" type
// (however, if wildcard, cache should not give hits...)
iQuestion.SetQType(aQType);
// -- only IN class queries are supported
iQuestion.SetQClass(EDnsQClass_IN);
if (iRecord)
{
iRecord->Unlock(this);
iRecord = NULL;
}
if (iCurrentServer == 0)
{
if (!PickDefaultServer())
{
SendResponse(KErrDndServerUnusable);
return 0;
}
if (iCurrentServer == 0)
{
// Cannot check cache nor start any query, if the
// name space id cannot be determined (no interfaces
// up). Return "query queued" anyway, and let the
// resolver retry process try it again later.
iIsReqPending = TRUE;
return 1;
}
}
TUint32 id = iOwner->iServerManager.NameSpace(iFilter, iCurrentServer);
if (id == 0)
{
SendResponse(KErrDndServerUnusable);
return 0;
}
// Check in the cache first. If the record does not exist
// in the cache, it will be created now (empty with KErrNotFound).
iRecord = iOwner->iCache->FindL(
id,
iQuestion,
iQuestion.QType(),
// *HACK WARNING* To achieve independent caching of answers which
// are result of queries where RD=1 or RD=0 (recursion desired),
// the Class value is made different depending on the RD state.
(EDnsQClass)(iQuestion.QClass() | ((iFlags & KDnsModifier_RD) ? 0 : 0x80)),
aRequestTime);
// The above FindL must either leave of return a valid
// record pointer. Just as a safety measure, if record
// is not returned, then panic on in DEBUG builds, and
// in release, leave with KErrDndNoRecord
// (** however, this should never happen! **)
ASSERT(iRecord != NULL);
if (iRecord == NULL)
User::Leave(KErrDndNoRecord);
// Prevent record from being deleted while the
// iRecord pointer exists...
iRecord->Lock();
switch(iRecord->ErrorCode())
{
// If no error in the record, retrieve the informations and send
case KErrNone:
// For certain errors, send the error code
case KErrDndBadName:
case KErrDndNotImplemented:
case KErrDndRefused:
case KErrDndNoRecord:
iIsFromCache = TRUE;
iIsNewQuery = FALSE;
if (IsQueued())
Cancel();
SendResponse(iRecord->ErrorCode());
return 0;
// For other errors, try sending the query to the DNS
default:
break;
}
// Automatic restart of DNS socket, if closed for some reason
CDnsSocketWriter *writerInstance = iOwner->ActivateSocketL(iNetworkId); // pass on the networkId information
iIsReqPending = TRUE;
// If the query is probe, do not AssignWork but continue..
if (!(iFlags & KDnsModifier_PQ) && !iRecord->AssignWork(this))
return 1; // just let the other worker do the job.
// Try to detect retransmissions of the same query and
// reuse old ID in such case... (don't generate a new)
if (iIsNewQuery ||
iQuestion.QType() != aQType ||
iQuestion.QClass() != EDnsQClass_IN)
Cancel(); // A new ID required
iIsNewQuery = FALSE;
iIsFromCache = FALSE;
// If the DNS "mode" is Multicast DNS, then assume that PTR queries
// which are generated from IP address are to be made via TCP. Test
// this and use TCP if query is PTR query for valid IP address.
// [specified in draft-ietf-dnsext-mdns-22.txt, but generalized here
// also for any future Multicast DNS]
for ( ;iFilter.IsMulticast() && iQuestion.QType() == EDnsQType_PTR;)
{
// Use "for" just for easy "break" exits!
TInetAddr server;
// Get correct DNS port number into 'server' (actual address is thrown away)
if (iOwner->iServerManager.Address(iCurrentServer, server) != KErrNone)
break;
// Use server address type as a flag, whether Ipv4 or IPv6 is done
const TInt is_ipv4 = server.IsV4Mapped();
if (!iQuestion.GetAddress(server) || !server.IsUnicast())
break;
// Usually LLMNR has both IPv4 and IPv6 multicast addresses as "servers".
// There is no point in doing PTR query for the same address twice, thus
// only do it once per matching "server" address (thus, if there is no
// IPv4 multicast "server", no IPv4 reverse queries are done either).
if (is_ipv4 != server.IsV4Mapped())
{
SendResponse(KErrDndServerUnusable);
return 0;
}
// Supplement 'server' address with a scope id based on current server
server.SetScope(iOwner->iServerManager.Scope(iCurrentServer, server));
// For link local multicast, use TTL = 1 (otherwise, system default is used)
const TInt ttl = iFilter.iServerScope == EDnsServerScope_MC_LOCAL ? 1 : -1;
if (iOwner->Queue(*this, server, writerInstance, -1, ttl) != KErrNone)
break;
iIsUsingTCP = 1;
SendResponse(KDnsNotify_USING_TCP);
return 1;
}
iOwner->ReSend(*this, writerInstance); // (uses old ID, if request queued already)
return 1;
}
// TDndReqData::UpdateCacheData
// ******************************
/**
// @param aQuery the session from which the reply is updated
// @param aMsg the reply from the DNS server
// @param aAnswerOffset the start offset to the andwer secion in the reply
// @param aErr the status code of the reply
// @returns
// @li TRUE, if cache record updated
// @li FALSE, if not updated (error code is "transient", concerns single query)
*/
TBool TDndReqData::UpdateCacheData(const TMsgBuf &aMsg, const TInt aAnswerOffset, const TInt aErr)
{
if (iRecord == NULL)
return FALSE;
#ifdef _LOG
THostName name;
iQuestion.GetName(name);
Log::Printf(_L("\t\tDNS session [%u] -- Update cache: %S (offset=%d) aErr=%d"), (TInt)this, &name, aAnswerOffset, aErr);
#endif
if (aErr == KErrDndDiscard)
return FALSE;
// If there is already have valid answer cached, decide whether the new
// answer is better and should replace the old?
const TInet6HeaderDNS &new_hdr = aMsg.Header();
if (iRecord->ErrorCode() == KErrNone && !new_hdr.AA())
{
// If new header is not authoritative, then it will replace the value
// only if old is non-authoritative and there is no error.
const TInet6HeaderDNS &old_hdr = iRecord->Header();
if (old_hdr.AA() || aErr != KErrNone)
return FALSE; // Not updated, keep previous valid value in cache.
}
TBool updated = FALSE;
if (aErr == KErrNone || aErr == KErrDndBadName || aErr == KErrDndNotImplemented || aErr == KErrDndNoRecord)
{
// Try to locate the SOA record from the authority section and
// use the minttl as the ttl of the negative caching.
TInt ttl;
TDndRR soa(aMsg);
#ifdef SYMBIAN_DNS_PUNYCODE
soa.iIdnEnabled = (TBool) iIdnEnabled;
#endif //SYMBIAN_DNS_PUNYCODE
TInt off = soa.LocateRR(aAnswerOffset, new_hdr.ANCOUNT()+new_hdr.NSCOUNT(), EDnsQType_SOA, EDnsQClass_IN, new_hdr.ANCOUNT());
if (off < 0)
{
ttl = iOwner->iControl.GetConfig().iMaxTime;
LOG(Log::Printf(_L("\t\tDNS session [%u] -- Update cache: no SOA, default ttl = %d"), (TInt)this, ttl));
}
else if ((off = aMsg.SkipName(soa.iRd)) > 0 &&
(off = aMsg.SkipName(off)) > 0 &&
off >= (TInt)soa.iRd &&
off + 20 <= (TInt)(soa.iRd + soa.iRdLength))
{
ttl = BigEndian::Get32(aMsg.Ptr()+off+16);
LOG(Log::Printf(_L("\t\tDNS session [%u] -- Update cache: SOA minttl = %d"), (TInt)this, ttl));
}
else
{
ttl = 0; // The reply is broken in some way, use ttl = 0
LOG(Log::Printf(_L("\t\tDNS session [%u] -- Update cache: SOA access failed"), (TInt)this));
}
iRecord->FillData(aMsg, aAnswerOffset, iCurrentServer, aErr, ttl);
#ifdef SYMBIAN_DNS_PUNYCODE
LOG(iRecord->Print(iOwner->iControl,(TBool)iIdnEnabled));
#else
LOG(iRecord->Print(iOwner->iControl));
#endif //SYMBIAN_DNS_PUNYCODE
updated = TRUE;
}
//
// Got some answer from a server, update the "good" server (unless error indicates "bad"
//
if (iFilter.IsUnicast() && aErr != KErrDndRefused && aErr != KErrDndServerUnusable)
{
TInetAddr addr;
if (iOwner->iServerManager.Address(iCurrentServer, addr) == KErrNone)
{
#ifdef _LOG
// borrow the 'name' from earlier LOG section!
addr.OutputWithScope(name);
Log::Printf(_L("\t\tDNS session [%u] -- Update cache: preferred server = %S port=%d ns=%d"),
(TInt)this, &name, addr.Port(), iOwner->iServerManager.NameSpace(iFilter, iCurrentServer));
#endif
iOwner->iCache->SetServerAddress(iOwner->iServerManager.NameSpace(iFilter, iCurrentServer), addr, KErrNone);
}
}
return updated;
}
void CDndDnsclient::QueryBegin()
{
// Query is going on
iQueryCount++;
LOG(Log::Printf(_L("CDndDnsclient::QueryBegin current query count = %d"), iQueryCount));
}
void CDndDnsclient::QueryEnd()
{
// if query has ended deactivate the associated sockets.
ASSERT(iQueryCount > 0);
if(iQueryCount > 0)
{
if (--iQueryCount == 0 )
{
LOG(Log::Printf(_L("CDndDnsclient::QueryEnd query count zero deactivating socket = %d"), iQueryCount));
DeactivateSocket();
}
}
else
{
// Call deactivate socket for safety purpose to release the sockets, no effect if already done
DeactivateSocket();
}
LOG(Log::Printf(_L("CDndDnsclient::QueryEnd current query count = %d"), iQueryCount));
}
//
// TDndReqData
//
// TDndReqData::TranslateRCODE
// ***************************
/**
//
// @param aHdr The fixed DNS reply header
//
// @returns
// @li KErrNone, if reply is ok
// @li KErrDndDiscard/KErrDndUnknown
// if reply does not match the query, has errors
// in the format or RCODE was unknown
// @li KErrDndFormat, RCODE was EDnsRcode_FORMAT_ERROR
// @li KErrDndServerFailure, RCODE was EDnsRcode_SERVER_FAILURE
// @li KErrDndBadName, RCODE was EDnsRcode_NAME_ERROR
// @li KErrDndNotImplemented, RCODE was EDnsRcode_NOT_IMPLEMENTED
// @li KErrDndRefuced, RCODE was EDnsRcode_REFUSED
// @li KErrDndServerUnusable, if empty reply is not authoritative
*/
TInt TDndReqData::TranslateRCODE(const TDndHeader &aHdr, TInt aRCode) const
{
switch (aRCode)
{
case EDnsRcode_NOERROR:
break;
case EDnsRcode_FORMAT_ERROR:
return KErrDndFormat;
case EDnsRcode_SERVER_FAILURE:
/*
In case the server returns the server failure, we just ignore the error code and
treat it as server unusable. so that the query is sent to the other available servers for resolution. Need more reasonable solution ???--
return KErrDndServerFailure; */
return KErrDndServerUnusable;
case EDnsRcode_NAME_ERROR:
return KErrDndBadName;
case EDnsRcode_NOT_IMPLEMENTED:
return KErrDndNotImplemented;
case EDnsRcode_REFUSED:
return KErrDndRefused;
default:
return KErrDndUnknown;
}
if (iOpcode == EDnsOpcode_QUERY && aHdr.QDCOUNT() != iQdCount)
return KErrDndDiscard;
//
// A special heuristics: discard empty replies, if the selected server does
// not do recursion as requested, and if it is not authority on the queried
// name. => return a special "server unusable for this query" error
if (aHdr.ANCOUNT() == 0 && (iFlags & KDnsModifier_RD) != 0 && !aHdr.RA() && !aHdr.AA())
return KErrDndServerUnusable;
return KErrNone;
}
// TDndReqData::CheckQuestion
// **************************
/**
// @param aOffset starting offset of the question section in the message
// @param aMsg the reply message from a DNS server
//
// @returns
// @li > 0,
// if message checks ok, the value is the new offset pointing
// to the next section after the question.
// @li = 0, reply does not match the question.
// @li < 0, bad DNS reply
*/
TInt TDndReqData::CheckQuestion(const TMsgBuf &aMsg, TInt &aRCode) const
{
if (!iIsReqPending)
return 0; // Not for me.
TDndQuestion question;
const TInt offset = aMsg.VerifyMessage(aRCode, question);
if (offset < 0)
return offset; // Invalid message format, just ignore.
const TDndHeader &hdr = aMsg.Header();
// Only ONE question supported, sematics of receiving a reply
// with more than one Question are hairy... [which answers
// relate to which question?] (and multiple questions are
// not supported by current servers anyway -- msa)
if (hdr.QDCOUNT() != 1)
return KErrDndUnknown;
// This is supposed to be a REPLY, if not, then "no match".
if (!hdr.QR())
return 0;
// Reply OPCODE match the query?
if (hdr.OPCODE() != iOpcode)
return KErrDndDiscard;
// Does the question match the query?
//
if (question.CheckQuestion(iQuestion) != KErrNone)
return 0;
return offset;
}
// TDndReqData::GetResponse
// ************************
/**
// Map the contents of single resource record into TNameRecord.
//
// @param aRR the resource from which the reply is extracted
// @retval aAnswer receives the extracted value
// @returns
// @li KErrNone, if extraction successful
// @li KErrDndNameTooBig, if answer cannot be fit into aAnswer
// @li and other errors
*/
TInt TDndReqData::GetResponse(const TDndRR &aRR, TNameRecord &aAnswer) const
{
TInt err = aRR.GetResponse(aAnswer.iName, TInetAddr::Cast(aAnswer.iAddr));
if (err != KErrNone)
return err;
aAnswer.iFlags |= (aRR.iType == EDnsType_CNAME) ? (EDnsAlias | EDnsServer) : EDnsServer;
return KErrNone;
}
// TDndReqData::SendResponce
// *************************
/**
// @param aErr is the status,
// @li = 0, the request has completed successfully
// @li > 0, request being processed, just a progress noticification
// @li < 0, the request has completed with an error
*/
void TDndReqData::SendResponse(TInt aErr)
{
if (aErr <= 0)
{
iIsReqPending = FALSE; // Current request completed
Cancel();
}
if (iCallback)
iCallback->ReplyCallback(aErr);
}
// TDndReqData::Build
// ******************
/**
// @retval aMsg
// contains the fully constructed message to be sent to the DNS server,
// if Build succeeds
// @retval aServer
// contains the server address for which the message should be sent
// @param aMaxMessage
// the size of the current receive buffer (if UDP, zero for TCP)
//
// @returns TRUE, successful Build, and error (< 0) otherwise
*/
TBool TDndReqData::Build(CDnsSocket &aSource, TMsgBuf &aMsg, TInetAddr &aServer, TInt aMaxMessage)
{
CDndDnsclient &dns = (CDndDnsclient &)aSource;
if (dns.iServerManager.Address(iCurrentServer, aServer) != KErrNone)
return 0;
ASSERT(aServer.Port() != 0);
aMsg.SetLength(sizeof(TDndHeader));
TDndHeader &hdr = (TDndHeader &)aMsg.Header();
if (aServer.IsMulticast())
{
ASSERT(iFilter.IsMulticast());
hdr.SetRD(0);
if (aServer.IsV4Mapped())
{
if(iQuestion.QType() == EDnsQType_AAAA)
{
SendResponse(KErrDndServerUnusable);
return 0;
}
}
else
{
if(iQuestion.QType() == EDnsQType_A)
{
SendResponse(KErrDndServerUnusable);
return 0;
}
}
#ifdef LLMNR_ENABLED
dns.SetHoplimit(dns.iControl.GetConfig().iLlmnrHoplimit);
#endif
}
else
{
#ifdef LLMNR_ENABLED
dns.SetHoplimit(-1);
#endif
hdr.SetRD(iFlags & KDnsModifier_RD);
}
hdr.SetQdCount(1);
if (iQuestion.Append(aMsg) < 0)
return 0;
// Assume EDNS0 enabled, if the current receive buffer
// is larger than KDnsMaxMessage (all smaller
// values are treated as "no EDNS0".
if (aMaxMessage > KDnsMaxMessage)
{
TDndRROut opt(aMsg);
#ifdef SYMBIAN_DNS_PUNYCODE
opt.iIdnEnabled = (TBool) iIdnEnabled;
#endif //SYMBIAN_DNS_PUNYCODE
opt.iType = (TUint16)EDnsQType_OPT;
opt.iClass = (TUint16)aMaxMessage;
opt.iTTL = 0; // RCODE = 0, version = 0, Z = 0
if (opt.Append(KNullDesC8, 0) == KErrNone)
{
hdr.SetArCount(1);
opt.AppendRData();
}
}
return 1;
}
void TDndReqData::Sent(CDnsSocket &aSource)
{
CDndDnsclient &dns = (CDndDnsclient &)aSource;
dns.iServerManager.CloseList(iFilter);
SendResponse(KDnsNotify_QUERY_SENT);
}
TBool TDndReqData::Reply(CDnsSocket &aSource, const TMsgBuf &aBuf, const TInetAddr &aServer)
{
TInt rcode = 0;
const TInt offset = CheckQuestion(aBuf, rcode);
if (offset < 0)
return 1; // Invalid message format, just ignore.
const TDndHeader &hdr = aBuf.Header();
TInt err = TranslateRCODE(hdr, rcode);
CDndDnsclient &dns = (CDndDnsclient &)aSource;
ASSERT(&dns == iOwner);
// If configuration requests that "Not found" replies from a server
// are not to be cached, but ignored, then substitue err with
// KErrDndServerUnusable (meaning that this server is not usable for
// this query) This error is not cached!
//
if (err == KErrDndBadName && dns.iControl.GetConfig().iSkipNotFound)
err = KErrDndServerUnusable;
else if (iIsUsingTCP == 0 && hdr.TC() != 0)
{
// The current query was not TCP and got truncated reply,
// restart query with TCP (if we get truncated reply with
// TCP, something is broken...)
//
// It is assumed that the aServer has the correct port
// already set (it should be the remote port of the original
// UDP query)
ASSERT(aServer.IsUnicast()); // Should always be true.
if (aServer.IsUnicast())
{
if (iOwner->Queue(*this, aServer, NULL, hdr.ID()) == KErrNone)
{
iIsUsingTCP = 1;
SendResponse(KDnsNotify_USING_TCP);
return 1;
}
}
// If cannot use the TCP, then just use the trunctated
// answer as is...
}
//
// UpdateCacheData updates data in cache only, if err is KErrNone, or
// updates error status for some specific err codes,
// otherwise, it does nothing.
TBool updated = UpdateCacheData(aBuf, offset, err);
#ifdef DEBUG_CACHE
iCache->Dump(*iControl);
#endif
if (updated)
{
// Cache modified! In addition to the original query,
// send the responce to every request that is waiting for
// the same reply... (iRecord pointers are same).
for (TUint i = 0; i < KDndNumRequests; ++i)
{
TDndReqData &rq = dns.iDndReqData[i];
if (rq.iIsReqPending && iRecord == rq.iRecord)
{
rq.Cancel(); // No need to send the query
rq.SendResponse(err);
}
}
return 1;
}
// Cache not updated, send to original query only.
SendResponse(err);
return 1;
}
void TDndReqData::Abort(CDnsSocket &/*aSource*/, const TInt aReason)
{
SendResponse(aReason);
}