DNSServer use default settings for catch-all setup

 - default constructor and start() method simply runs a catch-all DNS setup
 - avoid string comparison for domain reqs in catch-all mode
 - use IPaddress class for _resolvedIP (looking for IPv6 support in future)

Author: vortigont

libraries/DNSServer/src/DNSServer.cpp

@@ -1,6 +1,8 @@
 #include "DNSServer.h"
 #include <lwip/def.h>
 #include <Arduino.h>
+#include <WiFi.h>
+
 
 // #define DEBUG_ESP_DNS
 #ifdef DEBUG_ESP_PORT
@@ -9,20 +11,34 @@
 #define DEBUG_OUTPUT Serial
 #endif
 
-DNSServer::DNSServer() : _port(0), _ttl(htonl(DNS_DEFAULT_TTL)), _errorReplyCode(DNSReplyCode::NonExistentDomain){}
+#define DNS_MIN_REQ_LEN  17          // minimal size for DNS request asking ROOT = DNS_HEADER_SIZE + 1 null byte for Name + 4 bytes type/class
+
+DNSServer::DNSServer() : _port(DNS_DEFAULT_PORT), _ttl(htonl(DNS_DEFAULT_TTL)), _errorReplyCode(DNSReplyCode::NonExistentDomain){}
+
+DNSServer::DNSServer(const String &domainName) : _port(DNS_DEFAULT_PORT), _ttl(htonl(DNS_DEFAULT_TTL)), _errorReplyCode(DNSReplyCode::NonExistentDomain), _domainName(domainName){};
+
+
+bool DNSServer::start(){
+  if (WiFi.getMode() & WIFI_AP){
+    _resolvedIP = WiFi.softAPIP();
+  } else return false;        // won't run if WiFi is not in AP mode
 
-DNSServer::~DNSServer(){}
+  _udp.close();
+  _udp.onPacket([this](AsyncUDPPacket& pkt){ this->_handleUDP(pkt); });
+  return _udp.listen(_port);
+}
 
 bool DNSServer::start(const uint16_t &port, const String &domainName,
                      const IPAddress &resolvedIP)
 {
   _port = port;
-  _domainName = domainName;
-  _resolvedIP[0] = resolvedIP[0];
-  _resolvedIP[1] = resolvedIP[1];
-  _resolvedIP[2] = resolvedIP[2];
-  _resolvedIP[3] = resolvedIP[3];
-  downcaseAndRemoveWwwPrefix(_domainName);
+  if (domainName != "*"){
+    _domainName = domainName;
+    downcaseAndRemoveWwwPrefix(_domainName);
+  } else
+    _domainName.clear();
+
+  _resolvedIP = resolvedIP;
   _udp.close();
   _udp.onPacket([this](AsyncUDPPacket& pkt){ this->_handleUDP(pkt); });
   return _udp.listen(_port);
@@ -51,8 +67,7 @@ void DNSServer::downcaseAndRemoveWwwPrefix(String &domainName)
 
 void DNSServer::_handleUDP(AsyncUDPPacket& pkt)
 {
-  size_t currentPacketSize = pkt.length();
-  if (currentPacketSize < DNS_HEADER_SIZE) return;
+  if (pkt.length() < DNS_MIN_REQ_LEN) return;         // truncated packet or not a DNS req
 
   // get DNS header (beginning of message)
   DNSHeader dnsHeader;
@@ -67,15 +82,15 @@ void DNSServer::_handleUDP(AsyncUDPPacket& pkt)
       // Each label contains a byte to describe its length and the label itself. The list of 
       // labels terminates with a zero-valued byte. In "github.com", we have two labels "github" & "com"
 */
-      const char * enoflbls = strchr((const char*)pkt.data() + DNS_HEADER_SIZE, 0);   // find end_of_label marker
+      const char * enoflbls = strchr(reinterpret_cast<const char*>(pkt.data()) + DNS_HEADER_SIZE, 0);   // find end_of_label marker
       ++enoflbls;                                                               // advance after null terminator
       dnsQuestion.QName = pkt.data() + DNS_HEADER_SIZE;                         // we can reference labels from the request
       dnsQuestion.QNameLength = enoflbls - (char*)pkt.data() - DNS_HEADER_SIZE;
       /*
         check if we aint going out of pkt bounds
         proper dns req should have label terminator at least 4 bytes before end of packet
       */
-      if (dnsQuestion.QNameLength < 3 || dnsQuestion.QNameLength > currentPacketSize - DNS_HEADER_SIZE - sizeof(dnsQuestion.QType) - sizeof(dnsQuestion.QClass)) return;              // malformed packet
+      if (dnsQuestion.QNameLength > pkt.length() - DNS_HEADER_SIZE - sizeof(dnsQuestion.QType) - sizeof(dnsQuestion.QClass)) return;              // malformed packet
 
       // Copy the QType and QClass
       memcpy( &dnsQuestion.QType,  enoflbls, sizeof(dnsQuestion.QType) );
@@ -85,8 +100,8 @@ void DNSServer::_handleUDP(AsyncUDPPacket& pkt)
     // will reply with IP only to "*" or if doman matches without www. subdomain
     if (dnsHeader.OPCode == DNS_OPCODE_QUERY &&
         requestIncludesOnlyOneQuestion(dnsHeader) &&
-        (_domainName == "*" ||
-         getDomainNameWithoutWwwPrefix((const char*)pkt.data() + DNS_HEADER_SIZE, dnsQuestion.QNameLength) == _domainName)
+        (_domainName.isEmpty() ||
+         getDomainNameWithoutWwwPrefix(static_cast<const unsigned char*>(dnsQuestion.QName), dnsQuestion.QNameLength) == _domainName)
        )
     {
       replyWithIP(pkt, dnsHeader, dnsQuestion);
@@ -106,14 +121,14 @@ bool DNSServer::requestIncludesOnlyOneQuestion(DNSHeader& dnsHeader)
 }
 
 
-String DNSServer::getDomainNameWithoutWwwPrefix(const char* start, size_t len)
+String DNSServer::getDomainNameWithoutWwwPrefix(const unsigned char* start, size_t len)
 {
   String parsedDomainName(start, --len);    // exclude trailing null byte from labels length, String constructor will add it anyway
 
   int pos = 0;
   while(pos<len)
   {
-    parsedDomainName.setCharAt(pos, 0x2e);  // replace len byte with dot char "."
+    parsedDomainName.setCharAt(pos, 0x2e);  // replace label len byte with dot char "."
     pos += *(start + pos);
     ++pos;
   }
@@ -151,23 +166,24 @@ void DNSServer::replyWithIP(AsyncUDPPacket& req, DNSHeader& dnsHeader, DNSQuesti
   rpl.write((unsigned char*) &answerClass, 2 );
   rpl.write((unsigned char*) &_ttl, 4);        // DNS Time To Live
   rpl.write((unsigned char*) &answerIPv4, 2 );
-  rpl.write(_resolvedIP, sizeof(_resolvedIP)); // The IP address to return
+  uint32_t ip = _resolvedIP;
+  rpl.write(reinterpret_cast<uint8_t*>(&ip), sizeof(uint32_t)); // The IPv4 address to return
 
   _udp.sendTo(rpl, req.remoteIP(), req.remotePort());
 
   #ifdef DEBUG_ESP_DNS
     DEBUG_OUTPUT.printf("DNS responds: %s for %s\n",
-            IPAddress(_resolvedIP).toString().c_str(), getDomainNameWithoutWwwPrefix((const char*)rpl.data() + DNS_HEADER_SIZE, dnsQuestion.QNameLength).c_str() );
+            _resolvedIP.toString().c_str(), getDomainNameWithoutWwwPrefix(static_cast<const unsigned char*>(dnsQuestion.QName), dnsQuestion.QNameLength).c_str() );
   #endif  
 }
 
 void DNSServer::replyWithCustomCode(AsyncUDPPacket& req, DNSHeader& dnsHeader)
 {
   dnsHeader.QR = DNS_QR_RESPONSE;
-  dnsHeader.RCode = (uint16_t)_errorReplyCode;
+  dnsHeader.RCode = static_cast<uint16_t>(_errorReplyCode);
   dnsHeader.QDCount = 0;
 
   AsyncUDPMessage rpl(sizeof(DNSHeader));
-  rpl.write((unsigned char*)&dnsHeader, sizeof(DNSHeader));
+  rpl.write(reinterpret_cast<const uint8_t*>(&dnsHeader), sizeof(DNSHeader));
   _udp.sendTo(rpl, req.remoteIP(), req.remotePort());
 }

libraries/DNSServer/src/DNSServer.h

@@ -5,8 +5,9 @@
 #define DNS_QR_RESPONSE 1
 #define DNS_OPCODE_QUERY 0
 #define DNS_DEFAULT_TTL 60        // Default Time To Live : time interval in seconds that the resource record should be cached before being discarded
-#define DNS_OFFSET_DOMAIN_NAME 12 // Offset in bytes to reach the domain name in the DNS message 
 #define DNS_HEADER_SIZE 12 
+#define DNS_OFFSET_DOMAIN_NAME DNS_HEADER_SIZE // Offset in bytes to reach the domain name labels in the DNS message
+#define DNS_DEFAULT_PORT  53
 
 enum class DNSReplyCode:uint16_t
 {
@@ -75,11 +76,30 @@ class DNSServer
 {
   public:
     DNSServer();
-    ~DNSServer();
+    /**
+     * @brief Construct a new DNSServer object
+     * builds DNS server with default parameters
+     * @param domainName - domain name to serve
+     */
+    DNSServer(const String &domainName);
+    ~DNSServer(){};                   // default d-tor
     void processNextRequest(){};      // stub, left for compatibility with an old version
     void setErrorReplyCode(const DNSReplyCode &replyCode);
     void setTTL(const uint32_t &ttl);
 
+    /**
+     * @brief Starts a server with current configuration or with default parameters
+     * if it's the first call.
+     * Defaults are:
+     * port: 53
+     * domainName: any
+     * ip: WiFi AP's IP address
+     * 
+     * @return true on success
+     * @return false if IP or socket error
+     */
+    bool start();
+
     // Returns true if successful, false if there are no sockets available
     bool start(const uint16_t &port,
               const String &domainName,
@@ -93,7 +113,7 @@ class DNSServer
     uint32_t _ttl;
     DNSReplyCode _errorReplyCode;
     String _domainName;
-    unsigned char _resolvedIP[4];
+    IPAddress _resolvedIP;
 
 
     void downcaseAndRemoveWwwPrefix(String &domainName);
@@ -106,7 +126,7 @@ class DNSServer
      * @param len labels length
      * @return String 
      */
-    String getDomainNameWithoutWwwPrefix(const char* start, size_t len);
+    String getDomainNameWithoutWwwPrefix(const unsigned char* start, size_t len);
     inline bool requestIncludesOnlyOneQuestion(DNSHeader& dnsHeader);
     void replyWithIP(AsyncUDPPacket& req, DNSHeader& dnsHeader, DNSQuestion& dnsQuestion);
     inline void replyWithCustomCode(AsyncUDPPacket& req, DNSHeader& dnsHeader);