Add DNS profile to public resolver

contracts/PublicResolver.sol

@@ -4,6 +4,7 @@ import "@ensdomains/ens/contracts/ENS.sol";
 import "./profiles/ABIResolver.sol";
 import "./profiles/AddrResolver.sol";
 import "./profiles/ContentHashResolver.sol";
+import "./profiles/DNSResolver.sol";
 import "./profiles/InterfaceResolver.sol";
 import "./profiles/NameResolver.sol";
 import "./profiles/PubkeyResolver.sol";
@@ -13,7 +14,7 @@ import "./profiles/TextResolver.sol";
  * A simple resolver anyone can use; only allows the owner of a node to set its
  * address.
  */
-contract PublicResolver is ABIResolver, AddrResolver, ContentHashResolver, InterfaceResolver, NameResolver, PubkeyResolver, TextResolver {
+contract PublicResolver is ABIResolver, AddrResolver, ContentHashResolver, DNSResolver, InterfaceResolver, NameResolver, PubkeyResolver, TextResolver {
     ENS ens;
 
     /**

contracts/profiles/DNSResolver.sol

@@ -0,0 +1,142 @@
+pragma solidity ^0.5.0;
+
+import "../ResolverBase.sol";
+import "@ensdomains/dnssec-oracle/contracts/RRUtils.sol";
+
+contract DNSResolver is ResolverBase {
+    using RRUtils for *;
+    using BytesUtils for bytes;
+
+    bytes4 constant private DNS_RECORD_INTERFACE_ID = 0xa8fa5682;
+
+    // DNSRecordChanged is emitted whenever a given node/name/resource's RRSET is updated.
+    event DNSRecordChanged(bytes32 indexed node, bytes name, uint16 resource, bytes record);
+    // DNSRecordDeleted is emitted whenever a given node/name/resource's RRSET is deleted.
+    event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource);
+    // DNSZoneCleared is emitted whenever a given node's zone information is cleared.
+    event DNSZoneCleared(bytes32 indexed node);
+
+    // Version the mapping for each zone.  This allows users who have lost
+    // track of their entries to effectively delete an entire zone by bumping
+    // the version number.
+    // node => version
+    mapping(bytes32=>uint256) private versions;
+
+    // The records themselves.  Stored as binary RRSETs
+    // node => version => name => resource => data
+    mapping(bytes32=>mapping(uint256=>mapping(bytes32=>mapping(uint16=>bytes)))) private records;
+
+    // Count of number of entries for a given name.  Required for DNS resolvers
+    // when resolving wildcards.
+    // node => version => name => number of records
+    mapping(bytes32=>mapping(uint256=>mapping(bytes32=>uint16))) private nameEntriesCount;
+
+    /**
+     * Set one or more DNS records.  Records are supplied in wire-format.
+     * Records with the same node/name/resource must be supplied one after the
+     * other to ensure the data is updated correctly. For example, if the data
+     * was supplied:
+     *     a.example.com IN A 1.2.3.4
+     *     a.example.com IN A 5.6.7.8
+     *     www.example.com IN CNAME a.example.com.
+     * then this would store the two A records for a.example.com correctly as a
+     * single RRSET, however if the data was supplied:
+     *     a.example.com IN A 1.2.3.4
+     *     www.example.com IN CNAME a.example.com.
+     *     a.example.com IN A 5.6.7.8
+     * then this would store the first A record, the CNAME, then the second A
+     * record which would overwrite the first.
+     *
+     * @param node the namehash of the node for which to set the records
+     * @param data the DNS wire format records to set
+     */
+    function setDNSRecords(bytes32 node, bytes calldata data) external authorised(node) {
+        uint16 resource = 0;
+        uint256 offset = 0;
+        bytes memory name;
+        bytes memory value;
+        bytes32 nameHash;
+        // Iterate over the data to add the resource records
+        for (RRUtils.RRIterator memory iter = data.iterateRRs(0); !iter.done(); iter.next()) {
+            if (resource == 0) {
+                resource = iter.dnstype;
+                name = iter.name();
+                nameHash = keccak256(abi.encodePacked(name));
+                value = bytes(iter.rdata());
+            } else {
+                bytes memory newName = iter.name();
+                if (resource != iter.dnstype || !name.equals(newName)) {
+                    setDNSRRSet(node, name, resource, data, offset, iter.offset - offset, value.length == 0);
+                    resource = iter.dnstype;
+                    offset = iter.offset;
+                    name = newName;
+                    nameHash = keccak256(name);
+                    value = bytes(iter.rdata());
+                }
+            }
+        }
+        if (name.length > 0) {
+            setDNSRRSet(node, name, resource, data, offset, data.length - offset, value.length == 0);
+        }
+    }
+
+    /**
+     * Obtain a DNS record.
+     * @param node the namehash of the node for which to fetch the record
+     * @param name the keccak-256 hash of the fully-qualified name for which to fetch the record
+     * @param resource the ID of the resource as per https://en.wikipedia.org/wiki/List_of_DNS_record_types
+     * @return the DNS record in wire format if present, otherwise empty
+     */
+    function dnsRecord(bytes32 node, bytes32 name, uint16 resource) public view returns (bytes memory) {
+        return records[node][versions[node]][name][resource];
+    }
+
+    /**
+     * Check if a given node has records.
+     * @param node the namehash of the node for which to check the records
+     * @param name the namehash of the node for which to check the records
+     */
+    function hasDNSRecords(bytes32 node, bytes32 name) public view returns (bool) {
+        return (nameEntriesCount[node][versions[node]][name] != 0);
+    }
+
+    /**
+     * Clear all information for a DNS zone.
+     * @param node the namehash of the node for which to clear the zone
+     */
+    function clearDNSZone(bytes32 node) public authorised(node) {
+        versions[node]++;
+        emit DNSZoneCleared(node);
+    }
+
+    function supportsInterface(bytes4 interfaceID) public pure returns(bool) {
+        return interfaceID == DNS_RECORD_INTERFACE_ID || super.supportsInterface(interfaceID);
+    }
+
+    function setDNSRRSet(
+        bytes32 node,
+        bytes memory name,
+        uint16 resource,
+        bytes memory data,
+        uint256 offset,
+        uint256 size,
+        bool deleteRecord) private
+    {
+        uint256 version = versions[node];
+        bytes32 nameHash = keccak256(name);
+        bytes memory rrData = data.substring(offset, size);
+        if (deleteRecord) {
+            if (records[node][version][nameHash][resource].length != 0) {
+                nameEntriesCount[node][version][nameHash]--;
+            }
+            delete(records[node][version][nameHash][resource]);
+            emit DNSRecordDeleted(node, name, resource);
+        } else {
+            if (records[node][version][nameHash][resource].length == 0) {
+                nameEntriesCount[node][version][nameHash]++;
+            }
+            records[node][version][nameHash][resource] = rrData;
+            emit DNSRecordChanged(node, name, resource, rrData);
+        }
+    }
+}