dnscache.h

Go to the documentation of this file.

/*
* Copyright (c) 2017 Sprint
* Copyright (c) 2019 Sprint
*
* 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.
*/

#ifndef __DNSCACHE_H
#define __DNSCACHE_H


#include <list>
#include <map>
#include <ares.h>

#include "dnsquery.h"
#include "eatomic.h"
#include "esynch.h"
#include "etevent.h"
#include "eip.h"

namespace DNS
{

   typedef int namedserverid_t;

   class Cache;
   class QueryProcessor;

   const namedserverid_t NS_DEFAULT = 0;

   
   class QueryProcessorThread : public EThreadBasic
   {
      friend QueryProcessor;

   public:
      QueryProcessorThread(QueryProcessor &qp);

      Void incActiveQueries() { m_activequeries.Increment(); }
      Void decActiveQueries() { m_activequeries.Decrement(); }
      int getActiveQueries()  { return m_activequeries.currCount(); }

      virtual Dword threadProc(Void *arg);

      Void shutdown();

   protected:
      static Void ares_callback( Void *arg, int status, int timeouts, unsigned char *abuf, int alen );

   private:
      QueryProcessorThread();
      Void wait_for_completion();

      Bool m_shutdown;
      QueryProcessor &m_qp;
      ESemaphorePrivate m_activequeries;
   };


   struct NamedServer
   {
      char address[128];
      int family;
      int udp_port;
      int tcp_port;
   };


   class QueryProcessor
   {
      friend Cache;
      friend QueryProcessorThread;
   public:

      QueryProcessor( Cache &cache );
      ~QueryProcessor();

      Cache &getCache() { return m_cache; }

      Void shutdown();

      QueryProcessorThread *getQueryProcessorThread() { return &m_qpt; }

      Void setLocalIpAddress(const char *address) { m_localip = address; }
      const EIpAddress &getLocalIp() { return m_localip; }

      Void addNamedServer(const char *address, int udp_port, int tcp_port);
      Void removeNamedServer(const char *address);
      Void applyNamedServers();

      EMutexPrivate &getChannelMutex() { return m_mutex; }

   protected:
      ares_channel getChannel() { return m_channel; }

      Void beginQuery( QueryPtr &q );
      Void endQuery();

   private:
      QueryProcessor();
      Void init();

      Cache &m_cache;
      QueryProcessorThread m_qpt;
      ares_channel m_channel;
      EIpAddress m_localip;
      std::map<const char *,NamedServer> m_servers;
      EMutexPrivate m_mutex;
   };


   #define SAVED_QUERY_TYPE "type"
   #define SAVED_QUERY_DOMAIN "domain"

   const uint16_t CR_SAVEQUERIES = EM_USER + 1;
   const uint16_t CR_FORCEREFRESH = EM_USER + 2;

   class CacheRefresher : EThreadPrivate
   {
      friend Cache;

   protected:
      CacheRefresher(Cache &cache, unsigned int maxconcur, int percent, long interval);

      virtual Void onInit() override;
      virtual Void onQuit() override;
      virtual Void onTimer( EThreadEventTimer *timer ) override;
      Void saveQueries( EThreadMessage &msg ) { _saveQueries(); }
      Void forceRefresh( EThreadMessage &msg ) { _forceRefresh(); }

      const EString &queryFileName() { return m_qfn; }
      long querySaveFrequency() { return m_qsf; }

      Void loadQueries(const char *qfn);
      Void loadQueries(const std::string &qfn) { loadQueries(qfn.c_str()); }
      Void initSaveQueries(const char *qfn, long qsf);
      Void saveQueries() { sendMessage(CR_SAVEQUERIES); }
      Void forceRefresh() { sendMessage(CR_FORCEREFRESH); }

      DECLARE_MESSAGE_MAP()

   private:
      CacheRefresher();
      static Void callback( QueryPtr q, Bool cacheHit, const Void *data );
      Void _submitQueries( std::list<QueryCacheKey> &keys );
      Void _refreshQueries();
      Void _saveQueries();
      Void _forceRefresh();

      Cache &m_cache;
      ESemaphorePrivate m_sem;
      int m_percent;
      EThreadEventTimer m_timer;
      long m_interval;
      Bool m_running;
      EString m_qfn;
      long m_qsf;
      EThreadEventTimer m_qst;
   };



   class Cache
   {
      friend QueryProcessor;
      friend QueryProcessorThread;

      friend CacheRefresher;

   public:
      Cache();
      ~Cache();

      static Cache& getInstance(namedserverid_t nsid);
      static Cache& getInstance() { return getInstance(NS_DEFAULT); }

      static unsigned int getRefreshConcurrent() { return m_concur; }
      static unsigned int setRefreshConcurrent(unsigned int concur) { return m_concur = concur; }

      static int getRefreshPercent() { return m_percent; }
      static int setRefreshPercent(int percent) { return m_percent = percent; }

      static long getRefeshInterval() { return m_interval; }
      static long setRefreshInterval(long interval) { return m_interval = interval; }

      static int getQueryTimeoutMS() { return m_querytimeout; }
      static int setQueryTimeoutMS(int timeout) { return m_querytimeout = timeout; }

      static int getQueryTries() { return m_querytries; }
      static int setQueryTries(int tries) { return m_querytries = tries; }

      Void addNamedServer(const char *address, int udp_port=53, int tcp_port=53);
      Void removeNamedServer(const char *address);
      Void applyNamedServers();
      Void setLocalIpAddress(const char *address);

      QueryPtr query( ns_type rtype, const std::string &domain, Bool &cacheHit, Bool ignorecache=false );
      Void query( ns_type rtype, const std::string &domain, CachedDNSQueryCallback cb, const Void *data=NULL, Bool ignorecache=false );

      Void loadQueries(const char *qfn);
      Void loadQueries(const std::string &qfn) { loadQueries(qfn.c_str()); }
      Void initSaveQueries(const char *qfn, long qsf);
      Void saveQueries();
      Void forceRefresh();

      namedserverid_t getNamedServerId() { return m_nsid; }

      long resetNewQueryCount() { return atomic_swap(m_newquerycnt, 0); }

   protected:
      Void updateCache( QueryPtr q );
      QueryPtr lookupQuery( ns_type rtype, const std::string &domain );
      QueryPtr lookupQuery( QueryCacheKey &qck );

      Void identifyExpired( std::list<QueryCacheKey> &keys, int percent );
      Void getCacheKeys( std::list<QueryCacheKey> &keys );

   private:

      static int m_ref;
      static unsigned int m_concur;
      static int m_percent;
      static long m_interval;
      static int m_querytimeout;
      static int m_querytries;

      QueryProcessor m_qp;
      CacheRefresher m_refresher;
      QueryCache m_cache;
      namedserverid_t m_nsid;
      ERWLock m_cacherwlock;
      long m_newquerycnt;
   };
}

#endif // #ifndef __DNSCACHE_H