smart_proxy_dns_dnsmasq 0.4

data/README.md

@@ -0,0 +1,50 @@
+# Dnsmasq Smart Proxy plugin
+
+
+This plugin adds a new DNS provider for managing records in dnsmasq.
+
+## Installation
+
+See [How_to_Install_a_Smart-Proxy_Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Smart-Proxy_Plugin)
+for how to install Smart Proxy plugins
+
+This plugin is compatible with Smart Proxy 1.15 or higher.
+
+## Configuration
+
+To enable this DNS provider, edit `/etc/foreman-proxy/settings.d/dns.yml` and set:
+
+    :use_provider: dns_dnsmasq
+
+Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dns_dnsmasq.yml` and include:
+
+* `backend` (*optional*): The backend to use, currently implemented ones are; `openwrt`, and `default`
+* `config_path`: The path to the configuration file.
+* `reload_cmd`: The command to use for reloading the dnsmasq configuration.
+* `dns_ttl`: The TTL values for the DNS data. (*currently unused*)
+
+For best results, `config_path` should point to a file in a dnsmasq `conf-dir` which only the smart-proxy accesses.
+
+**NB**: The `openwrt` backend uses the UCI configuration files, which for the moment don't support IPv6 entries.
+
+## Contributing
+
+Fork and send a Pull Request. Thanks!
+
+## Copyright
+
+Copyright (c) 2017 Alexander Olofsson
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+

data/bundler.d/dns_dnsmasq.rb

@@ -0,0 +1 @@
+gem 'smart_proxy_dns_dnsmasq'

data/config/dns_dnsmasq.yml

@@ -0,0 +1,9 @@
+---
+#
+# Configuration file for 'dns_dnsmasq' dns provider
+#
+
+#
+#:backend: default
+:config_path: /etc/dnsmasq.d/foreman.conf
+:reload_cmd: systemctl reload dnsmasq

data/lib/smart_proxy_dns_dnsmasq.rb

@@ -0,0 +1,3 @@
+require 'smart_proxy_dns_dnsmasq/dns_dnsmasq_plugin'
+
+module Proxy::Dns::Dnsmasq; end

data/lib/smart_proxy_dns_dnsmasq/backend/default.rb

@@ -0,0 +1,168 @@
+module Proxy::Dns::Dnsmasq
+  class Default < ::Proxy::Dns::Dnsmasq::Record
+    attr_reader :config_file, :reload_cmd, :dirty
+
+    def initialize(config, reload_cmd, dns_ttl)
+      @config_file = config
+      @reload_cmd = reload_cmd
+      @dirty = false
+
+      super(dns_ttl)
+    end
+
+    def update!
+      return unless @dirty
+      @dirty = false
+
+      File.write(@config_file, configuration.join("\n") + "\n")
+      system(@reload_cmd)
+    end
+
+    def add_entry(type, fqdn, ip)
+      case type
+      when 'A', 'AAAA'
+        e = AddressEntry.new
+        e.ip = ip
+        e.fqdn = [fqdn]
+      when 'PTR'
+        e = PTREntry.new
+        e.ip = IPAddr.new(ip).reverse
+        e.fqdn = fqdn
+      end
+
+      configuration << e
+      @dirty = true
+    end
+
+    def remove_entry(type, fqdn = nil, ip = nil)
+      return true unless case type
+      when 'A', 'AAAA'
+        e = configuration.find { |entry| entry.is_a?(AddressEntry) && entry.fqdn.include?(fqdn) }
+      when 'PTR'
+        e = configuration.find { |entry| entry.is_a?(PTREntry) && entry.fqdn == fqdn }
+      end
+
+      configuration.delete e
+      @dirty = true
+    end
+
+    def add_cname(name, canonical)
+      # dnsmasq will silently ignore broken CNAME records, even though they stay in config
+      # So avoid flooding the configuration if broken CNAME entries are added
+      return true if configuration.find { |entry| entry.is_a?(CNAMEEntry) && entry.name == name }
+
+      c = CNAMEEntry.new
+      c.name = name
+      c.target = canonical
+      configuration << c
+      @dirty = true
+    end
+
+    def remove_cname(name)
+      c = configuration.find { |entry| entry.is_a?(CNAMEEntry) && entry.name == name }
+      return true unless c
+
+      configuration.delete c
+      @dirty = true
+    end
+
+    private
+
+    def load!
+      @configuration = []
+      File.open(@config_file).each_line do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?('#') || !line.include?('=')
+
+        option, value = line.split('=')
+
+        case option
+        when 'address'
+          data = value.split('/')
+          data.shift
+
+          entry = AddressEntry.new
+          entry.ip = data.pop
+          entry.fqdn = data
+        when 'cname'
+          data = value.split(',')
+
+          entry = CNAMEEntry.new
+          entry.name = data.shift
+          entry.target = data.shift
+          entry.ttl = data.shift
+        when 'ptr-record'
+          data = value.split(',')
+
+          entry = PTREntry.new
+          entry.ip = data[0]
+          entry.fqdn = data[1]
+#       TODO: Handle these properly
+#       when 'host-record'
+#         data = value.split(',')
+
+#         entry = HostEntry.new
+#         until data.empty?
+#           v = data.pop
+#           if !entry.ttl && /\A\d+\z/ === v
+#             entry.ttl = v
+#           end
+
+#           begin
+#             ip = IPAddr.new(v)
+#             entry.ip << v
+#           rescue IPAddr::InvalidAddressError
+#             entry.fqdn << v
+#           end
+#         end
+        end
+
+        @configuration << entry if entry
+      end
+    end
+
+    def configuration
+      load! unless @configuration
+      @configuration
+    end
+
+    class AddressEntry
+      attr_accessor :fqdn, :ip
+      def initialize
+        @fqdn = []
+      end
+
+      def to_s
+        "address=/#{fqdn.join '/'}/#{ip}"
+      end
+    end
+
+    class CNAMEEntry
+      attr_accessor :name, :target, :ttl
+
+      def to_s
+        "cname=#{name},#{target}#{ttl && ',' + ttl}"
+      end
+    end
+
+    class PTREntry
+      attr_accessor :fqdn, :ip
+
+      def to_s
+        "ptr-record=#{ip},#{fqdn}"
+      end
+    end
+
+    class HostEntry
+      attr_accessor :ttl, :ip, :fqdn
+      def initialize
+        @fqdn = []
+        @ip = []
+      end
+
+      def to_s
+        "host-record=#{fqdn.join ','},#{ip.join ','}#{ttl && ',' + ttl}"
+      end
+    end
+  end
+end

data/lib/smart_proxy_dns_dnsmasq/backend/openwrt.rb

@@ -0,0 +1,141 @@
+require 'ipaddr'
+
+module Proxy::Dns::Dnsmasq
+  class Openwrt < ::Proxy::Dns::Dnsmasq::Record
+    attr_reader :config_file, :reload_cmd, :dirty
+
+    def initialize(config, reload_cmd, dns_ttl)
+      @config_file = config
+      @reload_cmd = reload_cmd
+      @dirty = false
+
+      super(dns_ttl)
+    end
+
+    def update!
+      return unless @dirty
+      @dirty = false
+
+      File.write(@config_file, "\n" + configuration.join("\n") + "\n")
+      system(@reload_cmd)
+    end
+
+    def add_entry(type, fqdn, ip)
+      raise Proxy::Dns::Error, "OpenWRT UCI can't manage IPv6 entries" if type == 'AAAA' || type == 'PTR' && IPAddr.new(ip).ipv6?
+      found = find_type(:domain, :name, fqdn)
+      return true if found && found.options[:ip] == ip
+
+      h = found
+      h = DSL::Config.new :domain unless h
+      h.options[:name] = fqdn
+      h.options[:ip] = ip
+
+      configuration << h unless found
+      @dirty = true
+    end
+
+    def remove_entry(type, fqdn = nil, ip = nil)
+      raise Proxy::Dns::Error, "OpenWRT UCI can't manage IPv6 entries" if type == 'AAAA' || type == 'PTR' && IPAddr.new(ip).ipv6?
+      return true unless h = find_type(:domain, fqdn && :name || :ip, fqdn || ip)
+
+      configuration.delete h
+      @dirty = true
+    end
+
+    def add_cname(name, canonical)
+      found = find_type(:cname, :name, name)
+      return true if found && found.options[:target] == canonical
+
+      c = found
+      c = DSL::Config.new :cname unless c
+      c.options[:cname] = name
+      c.options[:target] = canonical
+
+      configuration << c unless found
+      @dirty = true
+    end
+
+    def remove_cname(name)
+      return true unless c = find_type(:cname, :name, name)
+
+      configuration.delete c
+      @dirty = true
+    end
+
+    private
+
+    def find_type(filter_type, search_type, value)
+      configuration.find do |config|
+        next unless config.type == filter_type
+
+        config.options.find do |name, opt|
+          next unless name == search_type
+
+          opt == value
+        end
+      end
+    end
+
+    def load!
+      @configuration = []
+      dsl = DSL.new(@configuration)
+      dsl.instance_eval open(@config_file).read, @config_file
+    end
+
+    def configuration
+      load! unless @configuration
+      @configuration
+    end
+
+    class DSL
+      class Config
+        attr_reader :type, :name, :options
+
+        def initialize(type, name = nil)
+          @type = type.to_sym
+          @name = name
+          @options = {}
+        end
+
+        def to_s
+          "config #{type} #{name}\n" + options.map do |name, value|
+            if value.is_a? Array
+              value.map do|val|
+                "        list #{name} '#{val}'"
+              end.join "\n"
+            else
+              "        option #{name} '#{value}'"
+            end
+          end.join("\n") + "\n"
+        end
+      end
+
+      def initialize(config)
+        @configs = config
+      end
+
+      def method_missing(m, *args)
+        [m, args].flatten
+      end
+
+      def config(args)
+        type, name = args
+        @current_config = Config.new type, name
+        @configs << @current_config 
+      end
+
+      def option(args)
+        name, value = args
+
+        @current_config.options[name] = value
+      end
+
+      def list(args)
+        name, value = args
+
+        @current_config.options[name] = [] unless @current_config.options[name]
+        @current_config.options[name] << value
+      end
+    end
+  end
+end

data/lib/smart_proxy_dns_dnsmasq/dns_dnsmasq_configuration.rb

@@ -0,0 +1,37 @@
+module ::Proxy::Dns::Dnsmasq
+  class PluginConfiguration
+    def load_classes
+      require 'dns_common/dns_common'
+      require 'smart_proxy_dns_dnsmasq/dns_dnsmasq_main'
+    end
+
+    BACKENDS = [ 'openwrt', 'default' ].freeze
+    def load_dependency_injection_wirings(container_instance, settings)
+      backend = settings[:backend] || 'default'
+
+      unless BACKENDS.include? backend
+        raise ::Proxy::Error::ConfigurationError, 'In'
+      end
+
+      begin
+        require "smart_proxy_dns_dnsmasq/backend/#{backend}"
+      rescue LoadError, e
+        raise ::Proxy::Error::ConfigurationError, "Failed to load backend #{backend}: #{e}"
+      end
+
+      klass = case backend
+      when 'openwrt'
+        ::Proxy::Dns::Dnsmasq::Openwrt
+      when 'default'
+        ::Proxy::Dns::Dnsmasq::Default
+      end
+
+      container_instance.dependency :dns_provider, (lambda do
+        klass.new(
+            settings[:config_path],
+            settings[:reload_cmd],
+            settings[:dns_ttl])
+      end)
+    end
+  end
+end

data/lib/smart_proxy_dns_dnsmasq/dns_dnsmasq_main.rb

@@ -0,0 +1,42 @@
+require 'dns_common/dns_common'
+require 'ipaddr'
+
+module Proxy::Dns::Dnsmasq
+  class Record < ::Proxy::Dns::Record
+    include Proxy::Log
+
+    def initialize(dns_ttl)
+      super('localhost', dns_ttl)
+    end
+
+    def do_create(name, value, type)
+      case type
+      when 'A', 'AAAA'
+        add_entry(type, name, value)
+      when 'PTR'
+        add_entry(type, value, ptr_to_ip(name))
+      when 'CNAME'
+        add_cname(name, value)
+      else
+        raise Proxy::Dns::Error, "Can't create entries of type #{type}"
+      end
+
+      update!
+    end
+
+    def do_remove(name, type)
+      case type
+      when 'A', 'AAAA'
+        remove_entry(type, name)
+      when 'PTR'
+        remove_entry(type, nil, ptr_to_ip(name))
+      when 'CNAME'
+        remove_cname(name)
+      else
+        raise Proxy::Dns::Error, "Can't remove entries of type #{type}"
+      end
+
+      update!
+    end
+  end
+end