(defpackage #:zone
(:use #:common-lisp
#:mdw.base #:mdw.str #:collect #:safely
- #:net #:services))
+ #:net #:services)
+ (:import-from #:net #:round-down #:round-up))
(in-package #:zone)
(cdr clause))))
clauses)))
+(export 'zone-parse-host)
+(defun zone-parse-host (f zname)
+ "Parse a host name F.
+
+ If F ends in a dot then it's considered absolute; otherwise it's relative
+ to ZNAME."
+ (setf f (stringify f))
+ (cond ((string= f "@") (stringify zname))
+ ((and (plusp (length f))
+ (char= (char f (1- (length f))) #\.))
+ (string-downcase (subseq f 0 (1- (length f)))))
+ (t (string-downcase (concatenate 'string f "."
+ (stringify zname))))))
+
+(export 'zone-make-name)
+(defun zone-make-name (prefix zone-name)
+ "Compute a full domain name from a PREFIX and a ZONE-NAME.
+
+ If the PREFIX ends with `.' then it's absolute already; otherwise, append
+ the ZONE-NAME, separated with a `.'. If PREFIX is nil, or `@', then
+ return the ZONE-NAME only."
+ (if (or (not prefix) (string= prefix "@"))
+ zone-name
+ (let ((len (length prefix)))
+ (if (or (zerop len) (char/= (char prefix (1- len)) #\.))
+ (join-strings #\. (list prefix zone-name))
+ prefix))))
+
+;;;--------------------------------------------------------------------------
+;;; Serial numbering.
+
+(export 'make-zone-serial)
+(defun make-zone-serial (name)
+ "Given a zone NAME, come up with a new serial number.
+
+ This will (very carefully) update a file ZONE.serial in the current
+ directory."
+ (let* ((file (zone-file-name name :serial))
+ (last (with-open-file (in file
+ :direction :input
+ :if-does-not-exist nil)
+ (if in (read in)
+ (list 0 0 0 0))))
+ (now (multiple-value-bind
+ (sec min hr dy mon yr dow dstp tz)
+ (get-decoded-time)
+ (declare (ignore sec min hr dow dstp tz))
+ (list dy mon yr)))
+ (seq (cond ((not (equal now (cdr last))) 0)
+ ((< (car last) 99) (1+ (car last)))
+ (t (error "Run out of sequence numbers for ~A" name)))))
+ (safely-writing (out file)
+ (format out
+ ";; Serial number file for zone ~A~%~
+ ;; (LAST-SEQ DAY MONTH YEAR)~%~
+ ~S~%"
+ name
+ (cons seq now)))
+ (from-mixed-base '(100 100 100) (reverse (cons seq now)))))
+
+;;;--------------------------------------------------------------------------
+;;; Zone form parsing.
+
(defun zone-process-records (rec ttl func)
"Sort out the list of records in REC, calling FUNC for each one.
;; Process the records we're given with no prefix.
(process rec nil ttl)))
-(export 'zone-parse-host)
-(defun zone-parse-host (f zname)
- "Parse a host name F.
-
- If F ends in a dot then it's considered absolute; otherwise it's relative
- to ZNAME."
- (setf f (stringify f))
- (cond ((string= f "@") (stringify zname))
- ((and (plusp (length f))
- (char= (char f (1- (length f))) #\.))
- (string-downcase (subseq f 0 (1- (length f)))))
- (t (string-downcase (concatenate 'string f "."
- (stringify zname))))))
-(defun default-rev-zone (base bytes)
- "Return the default reverse-zone name for the given BASE address and number
- of fixed leading BYTES."
- (join-strings #\. (collecting ()
- (loop for i from (- 3 bytes) downto 0
- do (collect (ipaddr-byte base i)))
- (collect "in-addr.arpa"))))
-
-(defun zone-name-from-net (net &optional bytes)
- "Given a NET, and maybe the BYTES to use, convert to the appropriate
- subdomain of in-addr.arpa."
- (let ((ipn (net-get-as-ipnet net)))
- (with-ipnet (net mask) ipn
- (unless bytes
- (setf bytes (- 4 (ipnet-changeable-bytes mask))))
- (join-strings #\.
- (append (loop
- for i from (- 4 bytes) below 4
- collect (logand #xff (ash net (* -8 i))))
- (list "in-addr.arpa"))))))
-
-(defun zone-net-from-name (name)
- "Given a NAME in the in-addr.arpa space, convert it to an ipnet."
- (let* ((name (string-downcase (stringify name)))
- (len (length name))
- (suffix ".in-addr.arpa")
- (sufflen (length suffix))
- (addr 0)
- (n 0)
- (end (- len sufflen)))
- (unless (and (> len sufflen)
- (string= name suffix :start1 end))
- (error "`~A' not in ~A." name suffix))
- (loop
- with start = 0
- for dot = (position #\. name :start start :end end)
- for byte = (parse-integer name
- :start start
- :end (or dot end))
- do (setf addr (logior addr (ash byte (* 8 n))))
- (incf n)
- when (>= n 4)
- do (error "Can't deduce network from ~A." name)
- while dot
- do (setf start (1+ dot)))
- (setf addr (ash addr (* 8 (- 4 n))))
- (make-ipnet addr (* 8 n))))
-
-(defun zone-parse-net (net name)
- "Given a NET, and the NAME of a domain to guess from if NET is null, return
- the ipnet for the network."
- (if net
- (net-get-as-ipnet net)
- (zone-net-from-name name)))
-
-(defun zone-cidr-delg-default-name (ipn bytes)
- "Given a delegated net IPN and the parent's number of changing BYTES,
- return the default deletate zone prefix."
- (with-ipnet (net mask) ipn
- (join-strings #\.
- (reverse
- (loop
- for i from (1- bytes) downto 0
- until (zerop (logand mask (ash #xff (* 8 i))))
- collect (logand #xff (ash net (* -8 i))))))))
-
-;;;--------------------------------------------------------------------------
-;;; Serial numbering.
-
-(export 'make-zone-serial)
-(defun make-zone-serial (name)
- "Given a zone NAME, come up with a new serial number.
-
- This will (very carefully) update a file ZONE.serial in the current
- directory."
- (let* ((file (zone-file-name name :serial))
- (last (with-open-file (in file
- :direction :input
- :if-does-not-exist nil)
- (if in (read in)
- (list 0 0 0 0))))
- (now (multiple-value-bind
- (sec min hr dy mon yr dow dstp tz)
- (get-decoded-time)
- (declare (ignore sec min hr dow dstp tz))
- (list dy mon yr)))
- (seq (cond ((not (equal now (cdr last))) 0)
- ((< (car last) 99) (1+ (car last)))
- (t (error "Run out of sequence numbers for ~A" name)))))
- (safely-writing (out file)
- (format out
- ";; Serial number file for zone ~A~%~
- ;; (LAST-SEQ DAY MONTH YEAR)~%~
- ~S~%"
- name
- (cons seq now)))
- (from-mixed-base '(100 100 100) (reverse (cons seq now)))))
-
-;;;--------------------------------------------------------------------------
-;;; Zone form parsing.
-
(defun zone-parse-head (head)
"Parse the HEAD of a zone form.
:min-ttl (timespec-seconds min-ttl)
:serial serial))))
-(export 'zone-make-name)
-(defun zone-make-name (prefix zone-name)
- "Compute a full domain name from a PREFIX and a ZONE-NAME.
-
- If the PREFIX ends with `.' then it's absolute already; otherwise, append
- the ZONE-NAME, separated with a `.'. If PREFIX is nil, or `@', then
- return the ZONE-NAME only."
- (if (or (not prefix) (string= prefix "@"))
- zone-name
- (let ((len (length prefix)))
- (if (or (zerop len) (char/= (char prefix (1- len)) #\.))
- (join-strings #\. (list prefix zone-name))
- prefix))))
-
(export 'defzoneparse)
(defmacro defzoneparse (types (name data list
&key (prefix (gensym "PREFIX"))
name))
(export 'defzone)
-(defmacro defzone (soa &rest zf)
+(defmacro defzone (soa &body zf)
"Zone definition macro."
`(zone-create '(,soa ,@zf)))
+(export '*address-family*)
+(defvar *address-family* t
+ "The default address family. This is bound by `defrevzone'.")
+
(export 'defrevzone)
-(defmacro defrevzone (head &rest zf)
+(defmacro defrevzone (head &body zf)
"Define a reverse zone, with the correct name."
- (destructuring-bind
- (net &rest soa-args)
+ (destructuring-bind (nets &rest args
+ &key &allow-other-keys
+ (family '*address-family*)
+ prefix-bits)
(listify head)
- (let ((bytes nil))
- (when (and soa-args (integerp (car soa-args)))
- (setf bytes (pop soa-args)))
- `(zone-create '((,(zone-name-from-net net bytes) ,@soa-args) ,@zf)))))
+ (with-gensyms (ipn)
+ `(dolist (,ipn (net-parse-to-ipnets ',nets ,family))
+ (let ((*address-family* (ipnet-family ,ipn)))
+ (zone-create `((,(reverse-domain ,ipn ,prefix-bits)
+ ,@',(loop for (k v) on args by #'cddr
+ unless (member k
+ '(:family :prefix-bits))
+ nconc (list k v)))
+ ,@',zf)))))))
+
+(defun map-host-addresses (func addr &key (family *address-family*))
+ "Call FUNC for each address denoted by ADDR (a `host-parse' address)."
+
+ (dolist (a (host-addrs (host-parse addr family)))
+ (funcall func a)))
+
+(defmacro do-host ((addr spec &key (family *address-family*)) &body body)
+ "Evaluate BODY, binding ADDR to each address denoted by SPEC."
+ `(dolist (,addr (host-addrs (host-parse ,spec ,family)))
+ ,@body))
+
+(export 'zone-set-address)
+(defun zone-set-address (rec addrspec &rest args
+ &key (family *address-family*) name ttl make-ptr-p)
+ "Write records (using REC) defining addresses for ADDRSPEC."
+ (declare (ignore name ttl make-ptr-p))
+ (let ((key-args (loop for (k v) on args by #'cddr
+ unless (eq k :family)
+ nconc (list k v))))
+ (do-host (addr addrspec :family family)
+ (apply rec :type (ipaddr-rrtype addr) :data addr key-args))))
;;;--------------------------------------------------------------------------
;;; Zone record parsers.
(defzoneparse :a (name data rec)
":a IPADDR"
- (rec :data (parse-ipaddr data) :make-ptr-p t))
+ (zone-set-address #'rec data :make-ptr-p t :family :ipv4))
+
+(defzoneparse :addr (name data rec)
+ ":addr IPADDR"
+ (zone-set-address #'rec data :make-ptr-p t))
(defzoneparse :svc (name data rec)
":svc IPADDR"
- (rec :type :a :data (parse-ipaddr data)))
+ (zone-set-address #'rec data))
(defzoneparse :ptr (name data rec :zname zname)
":ptr HOST"
(mxname &key (prio *default-mx-priority*) ip)
(listify mx)
(let ((host (zone-parse-host mxname zname)))
- (when ip (rec :name host :type :a :data (parse-ipaddr ip)))
+ (when ip (zone-set-address #'rec ip :name host))
(rec :data (cons host prio))))))
(defzoneparse :ns (name data rec :zname zname)
(nsname &key ip)
(listify ns)
(let ((host (zone-parse-host nsname zname)))
- (when ip (rec :name host :type :a :data (parse-ipaddr ip)))
+ (when ip (zone-set-address #'rec ip :name host))
(rec :data host)))))
(defzoneparse :alias (name data rec :zname zname)
ip)
(listify prov)
(let ((host (zone-parse-host srvname zname)))
- (when ip (rec :name host :type :a :data (parse-ipaddr ip)))
+ (when ip (zone-set-address #'rec ip :name host))
(rec :name rname
:data (list prio weight port host))))))))))
(defzoneparse :net (name data rec)
":net (NETWORK*)"
(dolist (net (listify data))
- (let ((n (net-get-as-ipnet net)))
- (rec :name (zone-parse-host "net" name)
- :type :a
- :data (ipnet-net n))
- (rec :name (zone-parse-host "mask" name)
- :type :a
- :data (ipnet-mask n))
- (rec :name (zone-parse-host "bcast" name)
- :type :a
- :data (ipnet-broadcast n)))))
+ (dolist (ipn (net-ipnets (net-must-find net)))
+ (let* ((base (ipnet-net ipn))
+ (rrtype (ipaddr-rrtype base)))
+ (flet ((frob (kind addr)
+ (when addr
+ (rec :name (zone-parse-host kind name)
+ :type rrtype
+ :data addr))))
+ (frob "net" base)
+ (frob "mask" (ipaddr (ipnet-mask ipn) (ipnet-family ipn)))
+ (frob "bcast" (ipnet-broadcast ipn)))))))
(defzoneparse (:rev :reverse) (name data rec)
- ":reverse ((NET :bytes BYTES) ZONE*)
+ ":reverse ((NET &key :prefix-bits :family) ZONE*)
Add a reverse record each host in the ZONEs (or all zones) that lies
- within NET. The BYTES give the number of prefix labels generated; this
- defaults to the smallest number of bytes needed to enumerate the net."
+ within NET."
(setf data (listify data))
- (destructuring-bind (net &key bytes) (listify (car data))
- (setf net (zone-parse-net net name))
- (unless bytes
- (setf bytes (ipnet-changeable-bytes (ipnet-mask net))))
- (let ((seen (make-hash-table :test #'equal)))
- (dolist (z (or (cdr data)
- (hash-table-keys *zones*)))
- (dolist (zr (zone-records (zone-find z)))
- (when (and (eq (zr-type zr) :a)
- (zr-make-ptr-p zr)
- (ipaddr-networkp (zr-data zr) net))
- (let ((name (string-downcase
- (join-strings
- #\.
- (collecting ()
- (dotimes (i bytes)
- (collect (logand #xff (ash (zr-data zr)
- (* -8 i)))))
- (collect name))))))
- (unless (gethash name seen)
- (rec :name name :type :ptr
- :ttl (zr-ttl zr) :data (zr-name zr))
- (setf (gethash name seen) t)))))))))
-
-(defzoneparse (:cidr-delegation :cidr) (name data rec :zname zname)
- ":cidr-delegation ((NET :bytes BYTES) ((TARGET-NET*) [TARGET-ZONE])*)
-
- Insert CNAME records for delegating a portion of the reverse-lookup
- namespace which doesn't align with an octet boundary.
-
- The NET specifies the origin network, in which the reverse records
- naturally lie. The BYTES are the number of labels to supply for each
- address; the default is the smallest number which suffices to enumerate
- the entire NET. The TARGET-NETs are subnets of NET which are to be
- delegated. The TARGET-ZONEs are the zones to which we are delegating
- authority for the reverse records: the default is to append labels for those
- octets of the subnet base address which are not the same in all address in
- the subnet."
- (setf data (listify data))
- (destructuring-bind (net &key bytes) (listify (car data))
- (setf net (zone-parse-net net name))
- (unless bytes
- (setf bytes (ipnet-changeable-bytes (ipnet-mask net))))
- (dolist (map (or (cdr data) (list (list net))))
- (destructuring-bind (tnets &optional tdom) (listify map)
- (dolist (tnet (listify tnets))
- (setf tnet (zone-parse-net tnet name))
- (unless (ipnet-subnetp net tnet)
- (error "~A is not a subnet of ~A."
- (ipnet-pretty tnet)
- (ipnet-pretty net)))
- (unless tdom
- (with-ipnet (net mask) tnet
- (setf tdom
- (join-strings
- #\.
- (append (reverse (loop
- for i from (1- bytes) downto 0
- until (zerop (logand mask
- (ash #xff
- (* 8 i))))
- collect (ldb (byte 8 (* i 8)) net)))
- (list name))))))
- (setf tdom (string-downcase (stringify tdom)))
- (dotimes (i (ipnet-hosts tnet))
- (unless (zerop i)
- (let* ((addr (ipnet-host tnet i))
- (tail (join-strings #\.
- (loop
- for i from 0 below bytes
- collect
- (logand #xff
- (ash addr (* 8 i)))))))
- (rec :name (format nil "~A.~A" tail name)
- :type :cname
- :data (format nil "~A.~A" tail tdom))))))))))
+ (destructuring-bind (net &key prefix-bits (family *address-family*))
+ (listify (car data))
+
+ (dolist (ipn (net-parse-to-ipnets net family))
+ (let* ((seen (make-hash-table :test #'equal))
+ (width (ipnet-width ipn))
+ (frag-len (if prefix-bits (- width prefix-bits)
+ (ipnet-changeable-bits width (ipnet-mask ipn)))))
+ (dolist (z (or (cdr data) (hash-table-keys *zones*)))
+ (dolist (zr (zone-records (zone-find z)))
+ (when (and (eq (zr-type zr) (ipaddr-rrtype (ipnet-net ipn)))
+ (zr-make-ptr-p zr)
+ (ipaddr-networkp (ipaddr-addr (zr-data zr)) ipn))
+ (let* ((frag (reverse-domain-fragment (zr-data zr)
+ 0 frag-len))
+ (name (concatenate 'string frag "." name)))
+ (unless (gethash name seen)
+ (rec :name name :type :ptr
+ :ttl (zr-ttl zr) :data (zr-name zr))
+ (setf (gethash name seen) t))))))))))
+
+(defzoneparse (:multi) (name data rec :zname zname :ttl ttl)
+ ":multi (((NET*) &key :start :end :family :suffix) . REC)
+
+ Output multiple records covering a portion of the reverse-resolution
+ namespace corresponding to the particular NETs. The START and END bounds
+ default to the most significant variable component of the
+ reverse-resolution domain.
+
+ The REC tail is a sequence of record forms (as handled by
+ `zone-process-records') to be emitted for each covered address. Within
+ the bodies of these forms, the symbol `*' will be replaced by the
+ domain-name fragment corresponding to the current host, optionally
+ followed by the SUFFIX.
+
+ Examples:
+
+ (:multi ((delegated-subnet :start 8)
+ :ns (some.ns.delegated.example :ip \"169.254.5.2\")))
+
+ (:multi ((tiny-subnet :suffix \"128.10.254.169.in-addr.arpa\")
+ :cname *))
+
+ Obviously, nested `:multi' records won't work well."
+
+ (destructuring-bind (nets &key start end (family *address-family*) suffix)
+ (listify (car data))
+ (dolist (net (listify nets))
+ (dolist (ipn (net-parse-to-ipnets net family))
+ (let* ((addr (ipnet-net ipn))
+ (width (ipaddr-width addr))
+ (comp-width (reverse-domain-component-width addr))
+ (end (round-up (or end
+ (ipnet-changeable-bits width
+ (ipnet-mask ipn)))
+ comp-width))
+ (start (round-down (or start (- end comp-width))
+ comp-width))
+ (map (ipnet-host-map ipn)))
+ (multiple-value-bind (host-step host-limit)
+ (ipnet-index-bounds map start end)
+ (do ((index 0 (+ index host-step)))
+ ((> index host-limit))
+ (let* ((addr (ipnet-index-host map index))
+ (frag (reverse-domain-fragment addr start end))
+ (target (concatenate 'string
+ (zone-make-name
+ (if (not suffix) frag
+ (concatenate 'string
+ frag "." suffix))
+ zname)
+ ".")))
+ (dolist (zr (zone-parse-records (zone-make-name frag zname)
+ ttl
+ (subst target '*
+ (cdr data))))
+ (rec :name (zr-name zr)
+ :type (zr-type zr)
+ :data (zr-data zr)
+ :ttl (zr-ttl zr)
+ :make-ptr-p (zr-make-ptr-p zr)))))))))))
;;;--------------------------------------------------------------------------
;;; Zone file output.
(subseq h 0 (- hl rl 1)))
(t (concatenate 'string h "."))))))
+(export 'bind-record)
+(defgeneric bind-record (type zr))
+
(defmethod zone-write ((format (eql :bind)) zone stream)
(format stream "~
;;; Zone file `~(~A~)'
(dolist (zr (zone-records zone))
(bind-record (zr-type zr) zr)))
-(export 'bind-record)
-(defgeneric bind-record (type zr))
-
(export 'bind-format-record)
(defun bind-format-record (name ttl type format args)
(format *zone-output-stream*
(string-upcase (symbol-name type))
format args))
-(defmethod bind-record (type zr)
- (destructuring-bind (format &rest args)
- (bind-record-format-args type (zr-data zr))
- (bind-format-record (zr-name zr)
- (zr-ttl zr)
- (bind-record-type type)
- format args)))
-
(export 'bind-record-type)
(defgeneric bind-record-type (type)
(:method (type) type))
(cons "~#[\"\"~;~S~:;(~@{~%~8T~S~} )~]"
(mapcar #'stringify (listify data)))))
+(defmethod bind-record (type zr)
+ (destructuring-bind (format &rest args)
+ (bind-record-format-args type (zr-data zr))
+ (bind-format-record (zr-name zr)
+ (zr-ttl zr)
+ (bind-record-type type)
+ format args)))
+
;;;----- That's all, folks --------------------------------------------------
~mdw / zone / blobdiff