-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-// TODO: Check the second param of postEvent. We sometimes omit it. Same

-// goes for the PlatformDomainNameResolver.

-

-#include <Swiften/Network/CAresDomainNameResolver.h>

-#include <Swiften/Base/Platform.h>

-

-#ifndef SWIFTEN_PLATFORM_WINDOWS

-#include <netdb.h>

-#include <arpa/inet.h>

-#endif

-#include <algorithm>

-

-#include <Swiften/Network/DomainNameServiceQuery.h>

-#include <Swiften/Network/DomainNameAddressQuery.h>

-#include <Swiften/Base/ByteArray.h>

-#include <Swiften/EventLoop/EventLoop.h>

-#include <Swiften/Base/foreach.h>

-

-namespace Swift {

-

-class CAresQuery : public boost::enable_shared_from_this<CAresQuery>, public EventOwner {

- public:

- CAresQuery(const std::string& query, int dnsclass, int type, CAresDomainNameResolver* resolver) : query(query), dnsclass(dnsclass), type(type), resolver(resolver) {

- }

-

- virtual ~CAresQuery() {

- }

-

- void addToQueue() {

- resolver->addToQueue(shared_from_this());

- }

-

- void doRun(ares_channel* channel) {

- ares_query(*channel, query.c_str(), dnsclass, type, &CAresQuery::handleResult, this);

- }

-

- static void handleResult(void* arg, int status, int timeouts, unsigned char* buffer, int len) {

- reinterpret_cast<CAresQuery*>(arg)->handleResult(status, timeouts, buffer, len);

- }

-

- virtual void handleResult(int status, int, unsigned char* buffer, int len) = 0;

-

- private:

- std::string query;

- int dnsclass;

- int type;

- CAresDomainNameResolver* resolver;

-};

-

-class CAresDomainNameServiceQuery : public DomainNameServiceQuery, public CAresQuery {

- public:

- CAresDomainNameServiceQuery(const std::string& service, CAresDomainNameResolver* resolver) : CAresQuery(service, 1, 33, resolver) {

- }

-

- virtual void run() {

- addToQueue();

- }

-

- void handleResult(int status, int, unsigned char* buffer, int len) {

- if (status == ARES_SUCCESS) {

- std::vector<DomainNameServiceQuery::Result> records;

- ares_srv_reply* rawRecords;

- if (ares_parse_srv_reply(buffer, len, &rawRecords) == ARES_SUCCESS) {

- for( ; rawRecords != NULL; rawRecords = rawRecords->next) {

- DomainNameServiceQuery::Result record;

- record.priority = rawRecords->priority;

- record.weight = rawRecords->weight;

- record.port = rawRecords->port;

- record.hostname = std::string(rawRecords->host);

- records.push_back(record);

- }

- }

- std::sort(records.begin(), records.end(), ResultPriorityComparator());

- eventLoop->postEvent(boost::bind(boost::ref(onResult), records));

- }

- else if (status != ARES_EDESTRUCTION) {

- eventLoop->postEvent(boost::bind(boost::ref(onResult), std::vector<DomainNameServiceQuery::Result>()), shared_from_this());

- }

- }

-};

-

-class CAresDomainNameAddressQuery : public DomainNameAddressQuery, public CAresQuery {

- public:

- CAresDomainNameAddressQuery(const std::string& host, CAresDomainNameResolver* resolver) : CAresQuery(host, 1, 1, resolver) {

- }

-

- virtual void run() {

- addToQueue();

- }

-

- void handleResult(int status, int, unsigned char* buffer, int len) {

- if (status == ARES_SUCCESS) {

- struct hostent* hosts;

- if (ares_parse_a_reply(buffer, len, &hosts, NULL, NULL) == ARES_SUCCESS) {

- // Check whether the different fields are what we expect them to be

- struct in_addr addr;

- addr.s_addr = *(unsigned int*)hosts->h_addr_list[0];

-

- std::vector<HostAddress> results;

- results.push_back(HostAddress(inet_ntoa(addr)));

-

- eventLoop->postEvent(boost::bind(boost::ref(onResult), results, boost::optional<DomainNameResolveError>()), boost::dynamic_pointer_cast<CAresDomainNameAddressQuery>(shared_from_this()));

- ares_free_hostent(hosts);

- }

- else {

- eventLoop->postEvent(boost::bind(boost::ref(onResult), std::vector<HostAddress>(), boost::optional<DomainNameResolveError>(DomainNameResolveError())), shared_from_this());

- }

- }

- else if (status != ARES_EDESTRUCTION) {

- eventLoop->postEvent(boost::bind(boost::ref(onResult), std::vector<HostAddress>(), boost::optional<DomainNameResolveError>(DomainNameResolveError())), shared_from_this());

- }

- }

-};

-

-CAresDomainNameResolver::CAresDomainNameResolver() : stopRequested(false) {

- ares_init(&channel);

- thread = new boost::thread(boost::bind(&CAresDomainNameResolver::run, this));

-}

-

-CAresDomainNameResolver::~CAresDomainNameResolver() {

- stopRequested = true;

- thread->join();

- ares_destroy(channel);

-}

-

-boost::shared_ptr<DomainNameServiceQuery> CAresDomainNameResolver::createServiceQuery(const std::string& name) {

- return boost::shared_ptr<DomainNameServiceQuery>(new CAresDomainNameServiceQuery(getNormalized(name), this));

-}

-

-boost::shared_ptr<DomainNameAddressQuery> CAresDomainNameResolver::createAddressQuery(const std::string& name) {

- return boost::shared_ptr<DomainNameAddressQuery>(new CAresDomainNameAddressQuery(getNormalized(name), this));

-}

-

-void CAresDomainNameResolver::addToQueue(boost::shared_ptr<CAresQuery> query) {

- boost::lock_guard<boost::mutex> lock(pendingQueriesMutex);

- pendingQueries.push_back(query);

-}

-

-void CAresDomainNameResolver::run() {

- fd_set readers, writers;

- struct timeval timeout;

- timeout.tv_sec = 0;

- timeout.tv_usec = 100000;

- while(!stopRequested) {

- {

- boost::unique_lock<boost::mutex> lock(pendingQueriesMutex);

- foreach(const boost::shared_ptr<CAresQuery>& query, pendingQueries) {

- query->doRun(&channel);

- }

- pendingQueries.clear();

- }

- FD_ZERO(&readers);

- FD_ZERO(&writers);

- int nfds = ares_fds(channel, &readers, &writers);

- //if (nfds) {

- // break;

- //}

- struct timeval tv;

- struct timeval* tvp = ares_timeout(channel, &timeout, &tv);

- select(nfds, &readers, &writers, NULL, tvp);

- ares_process(channel, &readers, &writers);

- }

-}

-

-}