knot-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 04ae67be521fbc10dc42972c8b3c7bfc9c0edc2822617a0ef565564e7e93bd6f
+  data.tar.gz: 89396bbc12e9aa181dcbf4af502262d4e8a4fb3ea982c28034c54d374078bd99
+SHA512:
+  metadata.gz: 8cf55c28b347d9f5103451ad60d0da577c1febf8909b10bd30449985057c7d8640777953de99ff5509736ead73b8a8f5a9329150948f1a2dea9c30e55728c738
+  data.tar.gz: 826ffdff42cbf5a3dd7fc0a54707796c283d13eb0e99478c293ac620cf4b179c24393f0c2db2638717904d7aec0ef097dda2c1cb3d566ad81ebfe43273e8b53c

data/.gitignore

@@ -0,0 +1,154 @@
+# ruby
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/Gemfile.lock
+
+# ---> Vim
+# Swap
+[._]*.s[a-v][a-z]
+!*.svg  # comment out if you don't need vector files
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+# Session
+Session.vim
+Sessionx.vim
+
+# Temporary
+.netrwhist
+*~
+# Auto-generated tag files
+tags
+# Persistent undo
+[._]*.un~
+
+# ---> Kate
+# Swap Files #
+.*.kate-swp
+.swp.*
+
+# ---> KDevelop4
+*.kdev4
+.kdev4/
+
+# ---> Emacs
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# Org-mode
+.org-id-locations
+*_archive
+
+# flymake-mode
+*_flymake.*
+
+# eshell files
+/eshell/history
+/eshell/lastdir
+
+# elpa packages
+/elpa/
+
+# reftex files
+*.rel
+
+# AUCTeX auto folder
+/auto/
+
+# cask packages
+.cask/
+dist/
+
+# Flycheck
+flycheck_*.el
+
+# server auth directory
+/server/
+
+# projectiles files
+.projectile
+
+# directory configuration
+.dir-locals.el
+
+# network security
+/network-security.data
+
+
+# ---> Eclipse
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# CDT- autotools
+.autotools
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Annotation Processing
+.apt_generated/
+.apt_generated_test/
+
+# Scala IDE specific (Scala & Java development for Eclipse)
+.cache-main
+.scala_dependencies
+.worksheet
+
+# ---> NotepadPP
+# Notepad++ backups #
+*.bak

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in knot.gemspec
+gemspec
+
+gem "rake", "~> 12.0"

data/LICENSE

@@ -0,0 +1,163 @@
+GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this license
+document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the terms
+and conditions of version 3 of the GNU General Public License, supplemented
+by the additional permissions listed below.
+
+   0. Additional Definitions.
+
+      
+
+As used herein, "this License" refers to version 3 of the GNU Lesser General
+Public License, and the "GNU GPL" refers to version 3 of the GNU General Public
+License.
+
+      
+
+"The Library" refers to a covered work governed by this License, other than
+an Application or a Combined Work as defined below.
+
+      
+
+An "Application" is any work that makes use of an interface provided by the
+Library, but which is not otherwise based on the Library. Defining a subclass
+of a class defined by the Library is deemed a mode of using an interface provided
+by the Library.
+
+      
+
+A "Combined Work" is a work produced by combining or linking an Application
+with the Library. The particular version of the Library with which the Combined
+Work was made is also called the "Linked Version".
+
+      
+
+The "Minimal Corresponding Source" for a Combined Work means the Corresponding
+Source for the Combined Work, excluding any source code for portions of the
+Combined Work that, considered in isolation, are based on the Application,
+and not on the Linked Version.
+
+      
+
+The "Corresponding Application Code" for a Combined Work means the object
+code and/or source code for the Application, including any data and utility
+programs needed for reproducing the Combined Work from the Application, but
+excluding the System Libraries of the Combined Work.
+
+   1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License without
+being bound by section 3 of the GNU GPL.
+
+   2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a facility
+refers to a function or data to be supplied by an Application that uses the
+facility (other than as an argument passed when the facility is invoked),
+then you may convey a copy of the modified version:
+
+a) under this License, provided that you make a good faith effort to ensure
+that, in the event an Application does not supply the function or data, the
+facility still operates, and performs whatever part of its purpose remains
+meaningful, or
+
+b) under the GNU GPL, with none of the additional permissions of this License
+applicable to that copy.
+
+   3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a header
+file that is part of the Library. You may convey such object code under terms
+of your choice, provided that, if the incorporated material is not limited
+to numerical parameters, data structure layouts and accessors, or small macros,
+inline functions and templates (ten or fewer lines in length), you do both
+of the following:
+
+a) Give prominent notice with each copy of the object code that the Library
+is used in it and that the Library and its use are covered by this License.
+
+b) Accompany the object code with a copy of the GNU GPL and this license document.
+
+   4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken together,
+effectively do not restrict modification of the portions of the Library contained
+in the Combined Work and reverse engineering for debugging such modifications,
+if you also do each of the following:
+
+a) Give prominent notice with each copy of the Combined Work that the Library
+is used in it and that the Library and its use are covered by this License.
+
+b) Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+c) For a Combined Work that displays copyright notices during execution, include
+the copyright notice for the Library among these notices, as well as a reference
+directing the user to the copies of the GNU GPL and this license document.
+
+      d) Do one of the following:
+
+0) Convey the Minimal Corresponding Source under the terms of this License,
+and the Corresponding Application Code in a form suitable for, and under terms
+that permit, the user to recombine or relink the Application with a modified
+version of the Linked Version to produce a modified Combined Work, in the
+manner specified by section 6 of the GNU GPL for conveying Corresponding Source.
+
+1) Use a suitable shared library mechanism for linking with the Library. A
+suitable mechanism is one that (a) uses at run time a copy of the Library
+already present on the user's computer system, and (b) will operate properly
+with a modified version of the Library that is interface-compatible with the
+Linked Version.
+
+e) Provide Installation Information, but only if you would otherwise be required
+to provide such information under section 6 of the GNU GPL, and only to the
+extent that such information is necessary to install and execute a modified
+version of the Combined Work produced by recombining or relinking the Application
+with a modified version of the Linked Version. (If you use option 4d0, the
+Installation Information must accompany the Minimal Corresponding Source and
+Corresponding Application Code. If you use option 4d1, you must provide the
+Installation Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+   5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library side
+by side in a single library together with other library facilities that are
+not Applications and are not covered by this License, and convey such a combined
+library under terms of your choice, if you do both of the following:
+
+a) Accompany the combined library with a copy of the same work based on the
+Library, uncombined with any other library facilities, conveyed under the
+terms of this License.
+
+b) Give prominent notice with the combined library that part of it is a work
+based on the Library, and explaining where to find the accompanying uncombined
+form of the same work.
+
+   6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions of the
+GNU Lesser General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to address
+new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library as you
+received it specifies that a certain numbered version of the GNU Lesser General
+Public License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that published version or of
+any later version published by the Free Software Foundation. If the Library
+as you received it does not specify a version number of the GNU Lesser General
+Public License, you may choose any version of the GNU Lesser General Public
+License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide whether
+future versions of the GNU Lesser General Public License shall apply, that
+proxy's public statement of acceptance of any version is permanent authorization
+for you to choose that version for the Library.

data/README.adoc

@@ -0,0 +1,46 @@
+Knot
+====
+
+Implements the knot-protocol.
+It is possible to write a knot-cli like knotc in ruby.
+Or your own tool, for provisioning.
+
+Installation
+============
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'knot'
+----
+
+And then execute:
+
+[source,sh]
+-----
+$ bundle install
+-----
+
+Or install it yourself as:
+
+[source,sh]
+-----
+$ gem install knot-ruby
+-----
+
+Usage
+-----
+
+TODO: Write usage instructions here
+
+Development
+-----------
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Contributing
+------------
+
+Bug reports and pull requests are welcome at https://git.denkn.at/deac/knot-ruby.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/knot-ruby.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/knot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "knot-ruby"
+  spec.version       = Knot::VERSION
+  spec.authors       = ['Denis Knauf']
+	spec.email         = ['gems+knot@denkn.at']
+	spec.licenses      = ["LGPL-3.0"]
+
+	spec.summary       = %q{Provides interface to knot-server.}
+  spec.description   = %q{Implements knot-protocol to provide an interface to knot-DNS-server}
+	spec.homepage      = 'https://git.denkn.at/deac/knot'
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+	spec.metadata["source_code_uri"] = spec.homepage
+	spec.metadata["changelog_uri"] = spec.homepage
+
+	spec.add_dependency 'iounpack', '~> 0'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/knot.rb

@@ -0,0 +1,4 @@
+require 'knot/version'
+require 'knot/errors'
+require 'knot/protocol'
+require 'knot/interface'

data/lib/knot/errors.rb

@@ -0,0 +1,166 @@
+module Knot
+	class Error < ::Exception
+		attr_reader :Errno
+		attr_reader :Key
+		attr_reader :Errstr
+	end
+end
+
+module Knot::Errors
+	@num2exc = {}
+	@key2exc = {}
+	@err2exc = {}
+	class << self
+		attr_reader :num2exc, :key2exc, :err2exc
+
+		def array_arguments_with_typecheck *args
+			l = args.length
+			lambda do |a|
+				l == a.length and
+					args.zip(a).all? {|t,v| t === v }
+			end
+		end
+	end
+
+	def method_missing key
+		self[key]
+	end
+
+	def [] key_or_errno
+		case key_or_errno
+		when Integer
+			@num2exc[key_or_errno]
+		when Exception
+			key_or_errno
+		when Symbol
+			@key2exc[key_or_errno]
+		else
+			raise ArgumentError, "Invalid type. Expect Integer/Knot::Error/Symbol"
+		end
+	end
+
+	i = 0
+	[
+		[:EOK,            0,                            "OK"],
+		# Directly mapped error codes.
+		[:ENOMEM,         -Errno::ENOMEM::Errno,        "not enough memory" ],
+		[:EINVAL,         -Errno::EINVAL::Errno,        "invalid parameter" ],
+		[:ENOTSUP,        -Errno::ENOTSUP::Errno,       "operation not supported" ],
+		[:EBUSY,          -Errno::EBUSY::Errno,         "requested resource is busy" ],
+		[:EAGAIN,         -Errno::EAGAIN::Errno,        "OS lacked necessary resources" ],
+		[:EACCES,         -Errno::EACCES::Errno,        "operation not permitted" ],
+		[:ECONNREFUSED,   -Errno::ECONNREFUSED::Errno,  "connection refused" ],
+		[:EISCONN,        -Errno::EISCONN::Errno,       "already connected" ],
+		[:EADDRINUSE,     -Errno::EADDRINUSE::Errno,    "address already in use" ],
+		[:ENOENT,         -Errno::ENOENT::Errno,        "not exists" ],
+		[:EEXIST,         -Errno::EEXIST::Errno,        "already exists" ],
+		[:ERANGE,         -Errno::ERANGE::Errno,        "value is out of range" ],
+		[:EADDRNOTAVAIL,  -Errno::EADDRNOTAVAIL::Errno, "address is not available" ],
+
+		# General errors.
+		[:ERROR,           -1000, "failed"],
+		[:EPARSEFAIL,             "parser failed"],
+		[:ESEMCHECK,              "semantic check"],
+		[:EUPTODATE,              "zone is up-to-date"],
+		[:EFEWDATA,               "not enough data to parse"],
+		[:ESPACE,                 "not enough space provided"],
+		[:EMALF,                  "malformed data"],
+		[:ENSEC3PAR,              "missing or wrong NSEC3PARAM record"],
+		[:ENSEC3CHAIN,            "missing or wrong NSEC3 chain in the zone"],
+		[:EOUTOFZONE,             "name does not belong to the zone"],
+		[:EZONEINVAL,             "invalid zone file"],
+		[:ENOZONE,                "no such zone found"],
+		[:ENONODE,                "no such node in zone found"],
+		[:ENORECORD,              "no such record in zone found"],
+		[:EISRECORD,              "such record already exists in zone"],
+		[:ENOMASTER,              "no usable master"],
+		[:EPREREQ,                "UPDATE prerequisity not met"],
+		[:ETTL,                   "TTL mismatch"],
+		[:ENOXFR,                 "transfer was not sent"],
+		[:EDENIED,                "not allowed"],
+		[:ECONN,                  "connection reset"],
+		[:ETIMEOUT,               "connection timeout"],
+		[:ENODIFF,                "cannot create zone diff"],
+		[:ENOTSIG,                "expected a TSIG or SIG(0)"],
+		[:ELIMIT,                 "exceeded response rate limit"],
+		[:EZONESIZE,              "zone size exceeded"],
+		[:EOF,                    "end of file"],
+		[:ESYSTEM,                "system error"],
+		[:EFILE,                  "file error"],
+		[:ESOAINVAL,              "SOA mismatch"],
+		[:ETRAIL,                 "trailing data"],
+		[:EPROCESSING,            "processing error"],
+
+		# Control states.
+		[:CTL_ESTOP,              "stopping server"],
+		# Network errors.
+		[:NET_EADDR,              "bad address or host name"],
+		[:NET_ESOCKET,            "can't create socket"],
+		[:NET_ECONNECT,           "can't connect"],
+		[:NET_ESEND,              "can't send data"],
+		[:NET_ERECV,              "can't receive data"],
+		[:NET_ETIMEOUT,           "network timeout"],
+		# Encoding errors.
+		[:BASE64_ESIZE,           "invalid base64 string length"],
+		[:BASE64_ECHAR,           "invalid base64 character"],
+		[:BASE32HEX_ESIZE,        "invalid base32hex string length"],
+		[:BASE32HEX_ECHAR,        "invalid base32hex character"],
+		# TSIG errors.
+		[:KNOT_TSIG_EBADSIG,      "failed to verify TSIG"],
+		[:KNOT_TSIG_EBADKEY,      "TSIG key not recognized or invalid"],
+		[:KNOT_TSIG_EBADTIME,     "TSIG out of time window"],
+		[:KNOT_TSIG_EBADTRUNC,    "TSIG bad truncation"],
+		# DNSSEC errors.
+		[:DNSSEC_ENOKEY,          "no keys for signing"],
+		[:DNSSEC_EMISSINGKEYTYPE, "missing active KSK or ZSK"],
+		# Yparser errors.
+		[:YP_ECHAR_TAB,           "tabulator character is not allowed"],
+		[:YP_EINVAL_ITEM,         "invalid item"],
+		[:YP_EINVAL_ID,           "invalid identifier"],
+		[:YP_EINVAL_DATA,         "invalid value"],
+		[:YP_EINVAL_INDENT,       "invalid indentation"],
+		[:YP_ENOTSUP_DATA,        "value not supported"],
+		[:YP_ENOTSUP_ID,          "identifier not supported"],
+		[:YP_ENODATA,             "missing value"],
+		[:YP_ENOID,               "missing identifier"],
+		# Configuration errors.
+		[:CONF_ENOTINIT,          "config DB not initialized"],
+		[:CONF_EVERSION,          "invalid config DB version"],
+		[:CONF_EREDEFINE,         "duplicate identifier"],
+		# Transaction errors.
+		[:TXN_EEXISTS,            "too many transactions"],
+		[:TXN_ENOTEXISTS,         "no active transaction"],
+		# DNSSEC errors.
+		[:INVALID_PUBLIC_KEY,     "invalid public key"],
+		[:INVALID_PRIVATE_KEY,    "invalid private key"],
+		[:INVALID_KEY_ALGORITHM,  "invalid key algorithm"],
+		[:INVALID_KEY_SIZE,       "invalid key size"],
+		[:INVALID_KEY_ID,         "invalid key ID"],
+		[:INVALID_KEY_NAME,       "invalid key name"],
+		[:NO_PUBLIC_KEY,          "no public key"],
+		[:NO_PRIVATE_KEY,         "no private key"],
+	].each do |v|
+		e = nil
+		case v
+		when array_arguments_with_typecheck( Symbol, String)
+			v, e = v
+		when array_arguments_with_typecheck( String, String)
+			v, e = v
+			v = v.to_sym
+		when array_arguments_with_typecheck( Symbol, Integer, String)
+			v, i, e = v
+		when array_arguments_with_typecheck( String, Integer, String)
+			v, i, e = v
+			v = v.to_sym
+		else
+			raise ArgumentError, "[Symbol, String] | [Symbol, Int, String] expected, not #{v}"
+		end
+		cl = Class.new Exception
+		cl.const_set :Key, v
+		cl.const_set :Errno, i
+		cl.const_set :Errstr, e
+		const_set v, cl
+		@num2exc[i] = @key2exc[v] = @err2exc[e] = cl
+		i += 1
+	end
+end

data/lib/knot/interface.rb

@@ -0,0 +1,159 @@
+require_relative 'protocol'
+require_relative 'errors'
+
+module Knot
+end
+
+class Knot::Zone
+	attr_reader :protocol, :zone
+	def initialize zone, protocol = nil
+		@protocol = protocol || Protocol.new
+		@zone, @transaction_opened = zone, 0
+	end
+
+	def begin
+		@transaction_opened += 1
+		@protocol.call command: 'zone-begin', zone: @zone  if 1 == @transaction_opened
+	end
+
+	def commit
+		@protocol.call command: 'zone-commit', zone: @zone  if 1 == @transaction_opened
+		@transaction_opened -= 1  if 0 < @transaction_opened
+	end
+
+	def abort
+		@protocol.call command: 'zone-abort', zone: @zone
+		@transaction_opened = 0
+	end
+
+	def transaction
+		self.begin
+		yield self
+	rescue Object
+		self.abort
+		raise
+	ensure
+		self.commit  unless $!
+	end
+
+	# zone operation
+
+	def check()       @protocol.call command: 'zone-check', zone: @zone  end
+	def reload()      @protocol.call command: 'zone-reload', zone: @zone  end
+	def refresh()     @protocol.call command: 'zone-refresh', zone: @zone  end
+	def notify()      @protocol.call command: 'zone-notify', zone: @zone  end
+	def retransfer()  @protocol.call command: 'zone-retransfer', zone: @zone  end
+	def sign()        @protocol.call command: 'zone-sign', zone: @zone  end
+	def freeze()      @protocol.call command: 'zone-freeze', zone: @zone  end
+	def thaw()        @protocol.call command: 'zone-thaw', zone: @zone  end
+	def status( filter = nil)  @protocol.call command: 'zone-status', zone: @zone, filter: filter  end
+
+	def stats( modul = nil, counter = nil)
+		@protocol.call command: 'zone-stats', zone: @zone, module: modul, counter: counter
+	end
+
+	# zone manipulation
+
+	def read() @protocol.call command: 'zone-read', zone: @zone end
+	def diff() @protocol.call command: 'zone-diff', zone: @zone end
+	
+	# setting record
+	# if data is nil, it will be unset.
+	def set owner, ttl = nil, type, data
+		@protocol.call command: data.nil? ? 'zone-unset' : 'zone-set',
+			zone: @zone, owner: owner, ttl: ttl, type: type, data: data
+	rescue Knot::Errors::EISRECORD, Knot::Errors::ENONODE, Knot::Errors::ENOENT
+	end
+	alias []= set
+
+	def unset owner, type = nil, data = nil
+		@protocol.call command: 'zone-unset',
+			zone: @zone, owner: owner, type: type, data: data
+	rescue Knot::Errors::ENONODE, Knot::Errors::ENOENT
+	end
+	alias delete unset
+
+	def get owner = nil, type = nil
+		@protocol.call command: 'zone-get',
+			zone: @zone, owner: owner, type: type
+	rescue Knot::Errors::ENONODE, Knot::Errors::ENOENT
+		nil
+	end
+	alias [] get
+end
+
+class Knot::Conf
+	def initialize protocol = nil
+		@protocol = protocol || Protocol.new
+		@transaction_opened = 0
+	end
+
+	def begin
+		@transaction_opened += 1
+		@protocol.call command: 'conf-begin'   if 1 == @transaction_opened
+	end
+
+	def commit
+		@protocol.call command: 'conf-commit'  if 1 == @transaction_opened
+		@transaction_opened -= 1  if 0 < @transaction_opened
+	end
+
+	def abort
+		@protocol.call command: 'conf-abort'
+		@transaction_opened = 0
+	end
+
+	def transaction
+		self.begin
+		yield self
+	rescue Object
+		self.abort
+		raise
+	ensure
+		self.commit
+	end
+
+	def parse_item k
+		case k
+		when k
+			case k.keys.sort
+			when %w[section], %w[id section], %w[item section], %w[id item section] then k
+			else raise ArgumentError, "Invalid Item-format"
+			end
+
+		when Array
+			case k.length
+			when 1 then {section: k[0]}
+			when 2 then {section: k[0], item: k[1]}
+			when 3 then {section: k[0], id: k[1], item: k[2]}
+			else raise ArgumentError, "Invalid Item-format"
+			end
+
+		when /\A
+					(?<section> [a-z0-9_-]+ )
+					(?: \[ (?<id> [a-z0-9_.-]+) \] )?
+					(?: \. (?<item>[a-z0-9_-]+) )?
+				\z/xi
+			$~.named_captures.delete_if {|_,v| v.nil? }
+		else raise ArgumentError, "Invalid Item-format"
+		end
+	end
+
+	def set item, value
+		@protocol.call parse_item( item).update( command: 'conf-set', data: value)
+	end
+	alias [] set
+
+	def unset item, value = nil
+		@protocol.call parse_item( item).update( command: 'conf-unset', data: value)
+	end
+	alias delete unset
+
+	def list item = nil
+		@protocol.call (item ? parse_item( item) : {}).update( command: 'conf-list')
+	end
+
+	def read item = nil
+		@protocol.call (item ? parse_item( item) : {}).update( command: 'conf-read')
+	end
+end

data/lib/knot/protocol.rb

@@ -0,0 +1,188 @@
+require 'iounpack'
+require_relative 'errors'
+
+module Knot
+	class Protocol
+	end
+end
+
+module Knot::Protocol::Type
+	def [] code
+		case code
+		when 0, End   then return End
+		when 1, Data  then return Data
+		when 2, Extra then return Extra
+		when 3, Block then return Block
+		end
+	end
+
+	class Base
+		def self.expect_data?
+			false
+		end
+		def expect_data?() self.class.expect_data? end
+		def code() self.class.code end
+	end
+	class End < Base
+		def self.code() 0 end
+	end
+	class Data < Base
+		def code() 1 end
+		def expect_data?
+			true
+		end
+		attr_reader :data
+		def initialize data
+			@data = data
+		end
+	end
+	class Extra < Base
+		def code() 2 end
+		def expect_data?
+			true
+		end
+		attr_reader :data
+		def initialize data
+			@data = data
+		end
+	end
+	class Block < Base
+		def code() 3 end
+	end
+end
+
+module Knot::Protocol::Idx
+	Idx = [
+		:command, # 10, :CMD,     # Control command name.
+		:flags,   # 11, :FLAGS,   # Control command flags.
+		:error,   # 12, :ERROR,   # Error message.
+		:section, # 13, :SECTION, # Configuration section name.
+		:item,    # 14, :ITEM,    # Configuration item name.
+		:id,      # 15, :ID,      # Congiguration item identifier.
+		:zone,    # 16, :ZONE,    # Zone name.
+		:owner,   # 17, :OWNER,   # Zone record owner
+		:ttl,     # 18, :TTL,     # Zone record TTL.
+		:type,    # 19, :TYPE,    # Zone record type name.
+		:data,    # 1a, :DATA,    # Configuration item/zone record data.
+		:filter,  # 1b, :FILTER,  # An option or a filter for output data processing.
+	]
+	Name = {}
+	Code = {}
+	Idx.each_with_index do |v, i|
+		Code[0x10+i] = v
+		Name[v] = i
+	end
+	def self.[] k
+		case k
+		when Symbol
+			Name[k] or raise Knot::Errors::EINVAL, "Unknown Idx: #{k}"
+		when Integer
+			Idx[k] or raise Knot::Errors::EINVAL, "Unknown Idx: #{k}"
+		else
+			raise ArgumentError, "Unknown Idx-Type: #{k}"
+		end
+	end
+end
+
+class Knot::Protocol
+	attr_reader :sock, :conf, :zones
+	attr_accessor :debug
+
+	def initialize path_or_sock = nil
+		case path_or_sock
+		when String, Pathname
+			@sock = UNIXSocket.new path_or_sock.to_s
+		when Socket
+			@sock = path_or_sock
+		when nil
+			@sock = UNIXSocket.new '/run/knot/knot.sock'
+		end
+		@debug = false
+		@conf = Knot::Conf.new self
+		@zones = Hash.new {|h, zone| h[zone] = Knot::Zone.new zone, self }
+	end
+
+	def snd sock: nil, **data
+		rsock = sock || @sock
+		s = ''
+		sock = StringIO.new s
+		sock.write [1].pack( 'c')
+		data[:flags] ||= ''
+		Idx::Idx.each_with_index do |n, i|
+			v = data[n]&.to_s
+			sock.write [0x10+i, v.size, v].pack( 'c na*')  if v
+		end
+		sock.write [3].pack( 'c')
+		sock.flush
+		STDERR.puts( {data: data, _: s}.inspect)  if @debug
+		rsock.write s
+		rsock.flush
+	end 
+
+	class RecordIO
+		attr_reader :str
+
+		def initialize sock, str = nil
+			@str, @sock = str || '', sock
+		end
+
+		def unpack pattern
+			IOUnpack.new(pattern).unpack self
+		end
+
+		def unpack1 pattern
+			IOUnpack.new(pattern).unpack1 self
+		end
+
+		def read n
+			s = @sock.read n
+			@str.insert -1, s
+			s
+		end
+	end
+
+	def rcv sock: nil
+		ret, r = [], nil
+		sock = sock || @sock
+		sock = RecordIO.new sock  if @debug
+		loop do
+			t = sock.unpack1 'c'
+			case t
+			when 0, 3
+				return ret
+			when 1, 2
+				type = t
+				ret.push( r = {})
+			else 
+				raise Knot::Errors::EINVAL, "Missing Type before: #{t}"  if ret.empty?
+				i = Idx::Idx[t - 0x10] or raise Knot::Errors::EINVAL, "Unknown index: #{t-0x10}"
+				l = sock.unpack1 'n'
+				r[i] = sock.read( l)
+			end
+		end
+	ensure
+		STDERR.puts( {rcvd: ret, read: sock.str}.inspect)  if @debug
+		ret
+	end
+
+	def call sock: nil, **data
+		snd sock: sock, **data
+		rcv( sock: sock).each do |r| 
+			if r[:error]
+				if e = Knot::Errors.err2exc[r[:error]]
+					raise e, r[:error]
+				end
+				raise Knot::Error, r[:error]
+			end
+		end
+	end
+
+	def zone( zone) @zones[zone.to_s.to_sym] end
+
+	def conf_set( **opts)   call opts.update( command: 'conf-set') end
+	def conf_unset( **opts) call opts.update( command: 'conf-set') end
+
+	def zone_set( **opts)   call opts.update( command: 'zone-set') end
+	def zone_unset( **opts) call opts.update( command: 'zone-unset') end
+	def zone_get( **opts)   call opts.update( command: 'zone-get') end
+end

data/lib/knot/version.rb

@@ -0,0 +1,3 @@
+module Knot
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: knot-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Denis Knauf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: iounpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Implements knot-protocol to provide an interface to knot-DNS-server
+email:
+- gems+knot@denkn.at
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.adoc
+- Rakefile
+- knot-ruby.gemspec
+- lib/knot.rb
+- lib/knot/errors.rb
+- lib/knot/interface.rb
+- lib/knot/protocol.rb
+- lib/knot/version.rb
+homepage: https://git.denkn.at/deac/knot
+licenses:
+- LGPL-3.0
+metadata:
+  homepage_uri: https://git.denkn.at/deac/knot
+  source_code_uri: https://git.denkn.at/deac/knot
+  changelog_uri: https://git.denkn.at/deac/knot
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Provides interface to knot-server.
+test_files: []